diff --git a/DQM/TrackingMonitorSource/python/TrackingSourceConfig_Tier0_cff.py b/DQM/TrackingMonitorSource/python/TrackingSourceConfig_Tier0_cff.py index aaeb59bb3fe03..a2cdc06931bc5 100644 --- a/DQM/TrackingMonitorSource/python/TrackingSourceConfig_Tier0_cff.py +++ b/DQM/TrackingMonitorSource/python/TrackingSourceConfig_Tier0_cff.py @@ -397,7 +397,7 @@ def _copyIfExists(mod, pset, name): from Configuration.ProcessModifiers.trackingLST_cff import trackingLST trackingLST.toModify(locals()["TrackSeedMonhighPtTripletStep"], - SeedProducer = "lstPixelSeedInputProducer" + SeedProducer = "lstInputProducer" ) TrackingDQMSourceTier0 += TrackSeedMonSequence diff --git a/DataFormats/Common/src/classes_def.xml b/DataFormats/Common/src/classes_def.xml index cbc3868eea51a..bc3e2059db47f 100644 --- a/DataFormats/Common/src/classes_def.xml +++ b/DataFormats/Common/src/classes_def.xml @@ -207,4 +207,5 @@ + diff --git a/Validation/RecoTrack/interface/trackFromSeedFitFailed.h b/DataFormats/TrackReco/interface/trackFromSeedFitFailed.h similarity index 70% rename from Validation/RecoTrack/interface/trackFromSeedFitFailed.h rename to DataFormats/TrackReco/interface/trackFromSeedFitFailed.h index 6a8479f6b6c8a..a271efee5918f 100644 --- a/Validation/RecoTrack/interface/trackFromSeedFitFailed.h +++ b/DataFormats/TrackReco/interface/trackFromSeedFitFailed.h @@ -1,5 +1,5 @@ -#ifndef Validation_RecoTrack_trackFomSeedFitFailed_h -#define Validation_RecoTrack_trackFomSeedFitFailed_h +#ifndef DataFormats_TrackReco_trackFomSeedFitFailed_h +#define DataFormats_TrackReco_trackFomSeedFitFailed_h #include "DataFormats/TrackReco/interface/Track.h" diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrackCandidates_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrackCandidates_cfi.py index 421a0f5cdd47a..93957d71c5571 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrackCandidates_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrackCandidates_cfi.py @@ -26,8 +26,8 @@ _hltInitialStepTrackCandidatesLST = cms.EDProducer('LSTOutputConverter', lstOutput = cms.InputTag('hltLST'), - phase2OTHits = cms.InputTag('hltPhase2OTHitsInputLST'), - lstPixelSeeds = cms.InputTag('hltPixelSeedInputLST'), + lstInput = cms.InputTag('hltInputLST'), + lstPixelSeeds = cms.InputTag('hltInputLST'), includeT5s = cms.bool(True), includeNonpLSTSs = cms.bool(False), propagatorAlong = cms.ESInputTag('', 'PropagatorWithMaterial'), diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrajectorySeedsLST_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrajectorySeedsLST_cfi.py index 26228c1c35b95..c3585a5b85511 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrajectorySeedsLST_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInitialStepTrajectorySeedsLST_cfi.py @@ -2,8 +2,8 @@ hltInitialStepTrajectorySeedsLST = cms.EDProducer('LSTOutputConverter', lstOutput = cms.InputTag('hltLST'), - phase2OTHits = cms.InputTag('hltPhase2OTHitsInputLST'), - lstPixelSeeds = cms.InputTag('hltPixelSeedInputLST'), + lstInput = cms.InputTag('hltInputLST'), + lstPixelSeeds = cms.InputTag('hltInputLST'), includeT5s = cms.bool(True), includeNonpLSTSs = cms.bool(True), propagatorAlong = cms.ESInputTag('', 'PropagatorWithMaterial'), diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltInputLST_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInputLST_cfi.py new file mode 100644 index 0000000000000..c5b871213485b --- /dev/null +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltInputLST_cfi.py @@ -0,0 +1,21 @@ +import FWCore.ParameterSet.Config as cms + +hltInputLST = cms.EDProducer('LSTInputProducer@alpaka', + ptCut = cms.double(0.8), + phase2OTRecHits = cms.InputTag('hltSiPhase2RecHits'), + beamSpot = cms.InputTag('hltOnlineBeamSpot'), + seedTracks = cms.VInputTag( + 'hltInitialStepSeedTracksLST', + 'hltHighPtTripletStepSeedTracksLST' + ), + alpaka = cms.untracked.PSet( + backend = cms.untracked.string('') + ) +) + +_hltInputLSTSingleIterPatatrack = hltInputLST.clone( + seedTracks = ['hltInitialStepSeedTracksLST'] +) + +from Configuration.ProcessModifiers.singleIterPatatrack_cff import singleIterPatatrack +singleIterPatatrack.toReplaceWith(hltInputLST, _hltInputLSTSingleIterPatatrack) diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltLST_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltLST_cfi.py index dd8337d88d205..2e75a7a866424 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltLST_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/modules/hltLST_cfi.py @@ -1,9 +1,9 @@ import FWCore.ParameterSet.Config as cms hltLST = cms.EDProducer('LSTProducer@alpaka', - pixelSeedInput = cms.InputTag('hltPixelSeedInputLST'), - phase2OTHitsInput = cms.InputTag('hltPhase2OTHitsInputLST'), + lstInput = cms.InputTag('hltInputLST'), verbose = cms.bool(False), + ptCut = cms.double(0.8), nopLSDupClean = cms.bool(False), tcpLSTriplets = cms.bool(False), mightGet = cms.optional.untracked.vstring, diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltPhase2OTHitsInputLST_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltPhase2OTHitsInputLST_cfi.py deleted file mode 100644 index ef388d2efd059..0000000000000 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltPhase2OTHitsInputLST_cfi.py +++ /dev/null @@ -1,6 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -hltPhase2OTHitsInputLST = cms.EDProducer('LSTPhase2OTHitsInputProducer', - phase2OTRecHits = cms.InputTag('hltSiPhase2RecHits'), - mightGet = cms.optional.untracked.vstring -) diff --git a/HLTrigger/Configuration/python/HLT_75e33/modules/hltPixelSeedInputLST_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/modules/hltPixelSeedInputLST_cfi.py deleted file mode 100644 index c85dfc1682512..0000000000000 --- a/HLTrigger/Configuration/python/HLT_75e33/modules/hltPixelSeedInputLST_cfi.py +++ /dev/null @@ -1,16 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -hltPixelSeedInputLST = cms.EDProducer('LSTPixelSeedInputProducer', - beamSpot = cms.InputTag('hltOnlineBeamSpot'), - seedTracks = cms.VInputTag( - 'hltInitialStepSeedTracksLST', - 'hltHighPtTripletStepSeedTracksLST' - ) -) - -_hltPixelSeedInputLSTSingleIterPatatrack = hltPixelSeedInputLST.clone( - seedTracks = ['hltInitialStepSeedTracksLST'] -) - -from Configuration.ProcessModifiers.singleIterPatatrack_cff import singleIterPatatrack -singleIterPatatrack.toReplaceWith(hltPixelSeedInputLST, _hltPixelSeedInputLSTSingleIterPatatrack) diff --git a/HLTrigger/Configuration/python/HLT_75e33/sequences/HLTInitialStepSequence_cfi.py b/HLTrigger/Configuration/python/HLT_75e33/sequences/HLTInitialStepSequence_cfi.py index 3ffb4c0d6063b..aa899f2527736 100644 --- a/HLTrigger/Configuration/python/HLT_75e33/sequences/HLTInitialStepSequence_cfi.py +++ b/HLTrigger/Configuration/python/HLT_75e33/sequences/HLTInitialStepSequence_cfi.py @@ -11,9 +11,8 @@ from ..modules.hltInitialStepSeedTracksLST_cfi import * from ..sequences.HLTHighPtTripletStepSeedingSequence_cfi import * from ..modules.hltHighPtTripletStepSeedTracksLST_cfi import * -from ..modules.hltPixelSeedInputLST_cfi import * from ..modules.hltSiPhase2RecHits_cfi import * -from ..modules.hltPhase2OTHitsInputLST_cfi import * +from ..modules.hltInputLST_cfi import * from ..modules.hltLST_cfi import * from ..modules.hltInitialStepTrackspTTCLST_cfi import * from ..modules.hltInitialStepTrackspLSTCLST_cfi import * @@ -27,9 +26,8 @@ +hltInitialStepSeedTracksLST +HLTHighPtTripletStepSeedingSequence +hltHighPtTripletStepSeedTracksLST - +hltPixelSeedInputLST +hltSiPhase2RecHits # Probably need to move elsewhere in the final setup - +hltPhase2OTHitsInputLST # Probably need to move elsewhere in the final setup + +hltInputLST +hltLST +hltInitialStepTrackCandidates +hltInitialStepTrackspTTCLST @@ -55,9 +53,8 @@ _HLTInitialStepSequenceSingleIterPatatrackLSTSeeding = cms.Sequence( hltInitialStepSeeds +hltInitialStepSeedTracksLST - +hltPixelSeedInputLST +hltSiPhase2RecHits # Probably need to move elsewhere in the final setup - +hltPhase2OTHitsInputLST # Probably need to move elsewhere in the final setup + +hltInputLST +hltLST +hltInitialStepTrajectorySeedsLST +hltInitialStepTrackCandidates diff --git a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py index 7c1dab22afd58..a3f402800e58e 100644 --- a/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py +++ b/RecoTracker/IterativeTracking/python/HighPtTripletStep_cff.py @@ -426,11 +426,10 @@ _HighPtTripletStepTask_LST = HighPtTripletStepTask.copy() from RecoLocalTracker.Phase2TrackerRecHits.Phase2TrackerRecHits_cfi import siPhase2RecHits from RecoTracker.LST.lstSeedTracks_cff import lstInitialStepSeedTracks,lstHighPtTripletStepSeedTracks -from RecoTracker.LST.lstPixelSeedInputProducer_cfi import lstPixelSeedInputProducer -from RecoTracker.LST.lstPhase2OTHitsInputProducer_cfi import lstPhase2OTHitsInputProducer +from RecoTracker.LST.lstInputProducer_cfi import lstInputProducer from RecoTracker.LST.lstProducerTask_cff import * -_HighPtTripletStepTask_LST.add(siPhase2RecHits, lstInitialStepSeedTracks, lstHighPtTripletStepSeedTracks, lstPixelSeedInputProducer, lstPhase2OTHitsInputProducer, +_HighPtTripletStepTask_LST.add(siPhase2RecHits, lstInitialStepSeedTracks, lstHighPtTripletStepSeedTracks, lstInputProducer, lstProducerTask, highPtTripletStepLSTpTracks, highPtTripletStepLSTT5Tracks, highPtTripletStepSelectorLSTT5) (trackingPhase2PU140 & trackingLST).toReplaceWith(HighPtTripletStepTask, _HighPtTripletStepTask_LST) diff --git a/RecoTracker/LST/interface/LSTPhase2OTHitsInput.h b/RecoTracker/LST/interface/LSTPhase2OTHitsInput.h deleted file mode 100644 index 00fd77846c4c3..0000000000000 --- a/RecoTracker/LST/interface/LSTPhase2OTHitsInput.h +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef RecoTracker_LST_interface_LSTPhase2OTHitsInput_h -#define RecoTracker_LST_interface_LSTPhase2OTHitsInput_h - -#include -#include - -#include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h" - -class LSTPhase2OTHitsInput { -public: - LSTPhase2OTHitsInput() = default; - LSTPhase2OTHitsInput(std::vector const detId, - std::vector const x, - std::vector const y, - std::vector const z, - std::vector const hits) - : detId_(std::move(detId)), x_(std::move(x)), y_(std::move(y)), z_(std::move(z)), hits_(std::move(hits)) {} - - std::vector const& detId() const { return detId_; } - std::vector const& x() const { return x_; } - std::vector const& y() const { return y_; } - std::vector const& z() const { return z_; } - std::vector const& hits() const { return hits_; } - -private: - std::vector detId_; - std::vector x_; - std::vector y_; - std::vector z_; - std::vector hits_; -}; - -#endif diff --git a/RecoTracker/LST/interface/LSTPixelSeedInput.h b/RecoTracker/LST/interface/LSTPixelSeedInput.h deleted file mode 100644 index 18d3768b2e0fc..0000000000000 --- a/RecoTracker/LST/interface/LSTPixelSeedInput.h +++ /dev/null @@ -1,75 +0,0 @@ -#ifndef RecoTracker_LST_interface_LSTPixelSeedInput_h -#define RecoTracker_LST_interface_LSTPixelSeedInput_h - -#include -#include - -class LSTPixelSeedInput { -public: - LSTPixelSeedInput() = default; - LSTPixelSeedInput(std::vector const px, - std::vector const py, - std::vector const pz, - std::vector const dxy, - std::vector const dz, - std::vector const ptErr, - std::vector const etaErr, - std::vector const stateTrajGlbX, - std::vector const stateTrajGlbY, - std::vector const stateTrajGlbZ, - std::vector const stateTrajGlbPx, - std::vector const stateTrajGlbPy, - std::vector const stateTrajGlbPz, - std::vector const q, - std::vector> const hitIdx) - : px_(std::move(px)), - py_(std::move(py)), - pz_(std::move(pz)), - dxy_(std::move(dxy)), - dz_(std::move(dz)), - ptErr_(std::move(ptErr)), - etaErr_(std::move(etaErr)), - stateTrajGlbX_(std::move(stateTrajGlbX)), - stateTrajGlbY_(std::move(stateTrajGlbY)), - stateTrajGlbZ_(std::move(stateTrajGlbZ)), - stateTrajGlbPx_(std::move(stateTrajGlbPx)), - stateTrajGlbPy_(std::move(stateTrajGlbPy)), - stateTrajGlbPz_(std::move(stateTrajGlbPz)), - q_(std::move(q)), - hitIdx_(std::move(hitIdx)) {} - - std::vector const& px() const { return px_; } - std::vector const& py() const { return py_; } - std::vector const& pz() const { return pz_; } - std::vector const& dxy() const { return dxy_; } - std::vector const& dz() const { return dz_; } - std::vector const& ptErr() const { return ptErr_; } - std::vector const& etaErr() const { return etaErr_; } - std::vector const& stateTrajGlbX() const { return stateTrajGlbX_; } - std::vector const& stateTrajGlbY() const { return stateTrajGlbY_; } - std::vector const& stateTrajGlbZ() const { return stateTrajGlbZ_; } - std::vector const& stateTrajGlbPx() const { return stateTrajGlbPx_; } - std::vector const& stateTrajGlbPy() const { return stateTrajGlbPy_; } - std::vector const& stateTrajGlbPz() const { return stateTrajGlbPz_; } - std::vector const& q() const { return q_; } - std::vector> const& hitIdx() const { return hitIdx_; } - -private: - std::vector px_; - std::vector py_; - std::vector pz_; - std::vector dxy_; - std::vector dz_; - std::vector ptErr_; - std::vector etaErr_; - std::vector stateTrajGlbX_; - std::vector stateTrajGlbY_; - std::vector stateTrajGlbZ_; - std::vector stateTrajGlbPx_; - std::vector stateTrajGlbPy_; - std::vector stateTrajGlbPz_; - std::vector q_; - std::vector> hitIdx_; -}; - -#endif diff --git a/RecoTracker/LST/plugins/BuildFile.xml b/RecoTracker/LST/plugins/BuildFile.xml index 49e9ee77f5a3b..f30edfb62694a 100644 --- a/RecoTracker/LST/plugins/BuildFile.xml +++ b/RecoTracker/LST/plugins/BuildFile.xml @@ -20,13 +20,14 @@ - + + diff --git a/RecoTracker/LST/plugins/LSTOutputConverter.cc b/RecoTracker/LST/plugins/LSTOutputConverter.cc index 13849e52a1209..73eac64f4acc3 100644 --- a/RecoTracker/LST/plugins/LSTOutputConverter.cc +++ b/RecoTracker/LST/plugins/LSTOutputConverter.cc @@ -13,7 +13,7 @@ #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" #include "MagneticField/Engine/interface/MagneticField.h" #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" -#include "RecoTracker/LST/interface/LSTPhase2OTHitsInput.h" +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" #include "RecoTracker/LST/interface/LSTOutput.h" #include "RecoTracker/TkSeedingLayers/interface/SeedingHitSet.h" @@ -36,7 +36,7 @@ class LSTOutputConverter : public edm::stream::EDProducer<> { void produce(edm::Event& iEvent, const edm::EventSetup& iSetup) override; const edm::EDGetTokenT lstOutputToken_; - const edm::EDGetTokenT lstPhase2OTHitsInputToken_; + const edm::EDGetTokenT lstInputToken_; const edm::EDGetTokenT lstPixelSeedToken_; const bool includeT5s_; const bool includeNonpLSTSs_; @@ -58,7 +58,7 @@ class LSTOutputConverter : public edm::stream::EDProducer<> { LSTOutputConverter::LSTOutputConverter(edm::ParameterSet const& iConfig) : lstOutputToken_(consumes(iConfig.getParameter("lstOutput"))), - lstPhase2OTHitsInputToken_{consumes(iConfig.getParameter("phase2OTHits"))}, + lstInputToken_{consumes(iConfig.getParameter("lstInput"))}, lstPixelSeedToken_{consumes(iConfig.getParameter("lstPixelSeeds"))}, includeT5s_(iConfig.getParameter("includeT5s")), includeNonpLSTSs_(iConfig.getParameter("includeNonpLSTSs")), @@ -89,8 +89,8 @@ void LSTOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descri edm::ParameterSetDescription desc; desc.add("lstOutput", edm::InputTag("lstProducer")); - desc.add("phase2OTHits", edm::InputTag("lstPhase2OTHitsInputProducer")); - desc.add("lstPixelSeeds", edm::InputTag("lstPixelSeedInputProducer")); + desc.add("lstInput", edm::InputTag("lstInputProducer")); + desc.add("lstPixelSeeds", edm::InputTag("lstInputProducer")); desc.add("includeT5s", true); desc.add("includeNonpLSTSs", false); desc.add("propagatorAlong", edm::ESInputTag{"", "PropagatorWithMaterial"}); @@ -113,7 +113,7 @@ void LSTOutputConverter::fillDescriptions(edm::ConfigurationDescriptions& descri void LSTOutputConverter::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { // Setup auto const& lstOutput = iEvent.get(lstOutputToken_); - auto const& phase2OTRecHits = iEvent.get(lstPhase2OTHitsInputToken_); + auto const& lstInputHC = iEvent.get(lstInputToken_); auto const& pixelSeeds = iEvent.get(lstPixelSeedToken_); auto const& mf = iSetup.getData(mfToken_); auto const& propAlo = iSetup.getData(propagatorAlongToken_); @@ -137,7 +137,7 @@ void LSTOutputConverter::produce(edm::Event& iEvent, const edm::EventSetup& iSet outputpTTC.reserve(lstTC_len.size()); outputpLSTC.reserve(lstTC_len.size()); - auto const& OTHits = phase2OTRecHits.hits(); + auto OTHits = lstInputHC.const_view().hits(); LogDebug("LSTOutputConverter") << "lstTC size " << lstTC_len.size(); for (unsigned int i = 0; i < lstTC_len.size(); i++) { diff --git a/RecoTracker/LST/plugins/LSTPhase2OTHitsInputProducer.cc b/RecoTracker/LST/plugins/LSTPhase2OTHitsInputProducer.cc deleted file mode 100644 index a0fcc72f598b6..0000000000000 --- a/RecoTracker/LST/plugins/LSTPhase2OTHitsInputProducer.cc +++ /dev/null @@ -1,67 +0,0 @@ -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "RecoTracker/LST/interface/LSTPhase2OTHitsInput.h" - -class LSTPhase2OTHitsInputProducer : public edm::global::EDProducer<> { -public: - explicit LSTPhase2OTHitsInputProducer(edm::ParameterSet const& iConfig); - ~LSTPhase2OTHitsInputProducer() override = default; - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - - const edm::EDGetTokenT phase2OTRecHitToken_; - const edm::EDPutTokenT lstPhase2OTHitsInputPutToken_; -}; - -LSTPhase2OTHitsInputProducer::LSTPhase2OTHitsInputProducer(edm::ParameterSet const& iConfig) - : phase2OTRecHitToken_(consumes(iConfig.getParameter("phase2OTRecHits"))), - lstPhase2OTHitsInputPutToken_(produces()) {} - -void LSTPhase2OTHitsInputProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - - desc.add("phase2OTRecHits", edm::InputTag("siPhase2RecHits")); - - descriptions.addWithDefaultLabel(desc); -} - -void LSTPhase2OTHitsInputProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - // Setup - auto const& phase2OTHits = iEvent.get(phase2OTRecHitToken_); - - // Vector definitions - std::vector ph2_detId; - ph2_detId.reserve(phase2OTHits.dataSize()); - std::vector ph2_x; - ph2_x.reserve(phase2OTHits.dataSize()); - std::vector ph2_y; - ph2_y.reserve(phase2OTHits.dataSize()); - std::vector ph2_z; - ph2_z.reserve(phase2OTHits.dataSize()); - std::vector ph2_hits; - ph2_hits.reserve(phase2OTHits.dataSize()); - - for (auto const& it : phase2OTHits) { - const DetId hitId = it.detId(); - for (auto const& hit : it) { - ph2_detId.push_back(hitId.rawId()); - ph2_x.push_back(hit.globalPosition().x()); - ph2_y.push_back(hit.globalPosition().y()); - ph2_z.push_back(hit.globalPosition().z()); - ph2_hits.push_back(&hit); - } - } - - LSTPhase2OTHitsInput phase2OTHitsInput( - std::move(ph2_detId), std::move(ph2_x), std::move(ph2_y), std::move(ph2_z), std::move(ph2_hits)); - iEvent.emplace(lstPhase2OTHitsInputPutToken_, std::move(phase2OTHitsInput)); -} - -DEFINE_FWK_MODULE(LSTPhase2OTHitsInputProducer); diff --git a/RecoTracker/LST/plugins/LSTPixelSeedInputProducer.cc b/RecoTracker/LST/plugins/LSTPixelSeedInputProducer.cc deleted file mode 100644 index 819baf78c6aa4..0000000000000 --- a/RecoTracker/LST/plugins/LSTPixelSeedInputProducer.cc +++ /dev/null @@ -1,171 +0,0 @@ -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "FWCore/Utilities/interface/transform.h" - -#include "MagneticField/Engine/interface/MagneticField.h" -#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" - -#include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2DCollection.h" -#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" - -#include "Validation/RecoTrack/interface/trackFromSeedFitFailed.h" - -#include "TrackingTools/Records/interface/TransientRecHitRecord.h" -#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" -#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" - -#include "RecoTracker/LST/interface/LSTPixelSeedInput.h" - -class LSTPixelSeedInputProducer : public edm::global::EDProducer<> { -public: - explicit LSTPixelSeedInputProducer(edm::ParameterSet const& iConfig); - ~LSTPixelSeedInputProducer() override = default; - - static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); - -private: - void produce(edm::StreamID, edm::Event& iEvent, const edm::EventSetup& iSetup) const override; - - const edm::ESGetToken mfToken_; - const edm::EDGetTokenT beamSpotToken_; - std::vector>> seedTokens_; - const edm::EDPutTokenT lstPixelSeedInputPutToken_; - const edm::EDPutTokenT lstPixelSeedsPutToken_; -}; - -LSTPixelSeedInputProducer::LSTPixelSeedInputProducer(edm::ParameterSet const& iConfig) - : mfToken_(esConsumes()), - beamSpotToken_(consumes(iConfig.getParameter("beamSpot"))), - lstPixelSeedInputPutToken_(produces()), - lstPixelSeedsPutToken_(produces()) { - seedTokens_ = edm::vector_transform(iConfig.getParameter>("seedTracks"), - [&](const edm::InputTag& tag) { return consumes>(tag); }); -} - -void LSTPixelSeedInputProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { - edm::ParameterSetDescription desc; - - desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); - - desc.add>("seedTracks", - std::vector{edm::InputTag("lstInitialStepSeedTracks"), - edm::InputTag("lstHighPtTripletStepSeedTracks")}); - - descriptions.addWithDefaultLabel(desc); -} - -void LSTPixelSeedInputProducer::produce(edm::StreamID iID, edm::Event& iEvent, const edm::EventSetup& iSetup) const { - // Setup - auto const& mf = iSetup.getData(mfToken_); - auto const& bs = iEvent.get(beamSpotToken_); - - // Vector definitions - std::vector see_px; - std::vector see_py; - std::vector see_pz; - std::vector see_dxy; - std::vector see_dz; - std::vector see_ptErr; - std::vector see_etaErr; - std::vector see_stateTrajGlbX; - std::vector see_stateTrajGlbY; - std::vector see_stateTrajGlbZ; - std::vector see_stateTrajGlbPx; - std::vector see_stateTrajGlbPy; - std::vector see_stateTrajGlbPz; - std::vector see_q; - std::vector> see_hitIdx; - TrajectorySeedCollection see_seeds; - - for (size_t iColl = 0; iColl < seedTokens_.size(); ++iColl) { - // Get seed tokens - auto const& seedToken = seedTokens_[iColl]; - auto const& seedTracks = iEvent.get(seedToken); - - if (seedTracks.empty()) - continue; - - // Get seed track refs - edm::RefToBaseVector seedTrackRefs; - for (edm::View::size_type i = 0; i < seedTracks.size(); ++i) { - seedTrackRefs.push_back(seedTracks.refAt(i)); - } - - edm::ProductID id = seedTracks[0].seedRef().id(); - - for (size_t iSeed = 0; iSeed < seedTrackRefs.size(); ++iSeed) { - auto const& seedTrackRef = seedTrackRefs[iSeed]; - auto const& seedTrack = *seedTrackRef; - auto const& seedRef = seedTrack.seedRef(); - auto const& seed = *seedRef; - - if (seedRef.id() != id) - throw cms::Exception("LogicError") - << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the " - "element 0 had ProductID " - << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id() << "."; - - const bool seedFitOk = !trackFromSeedFitFailed(seedTrack); - - const TrackingRecHit* lastRecHit = &*(seed.recHits().end() - 1); - TrajectoryStateOnSurface tsos = - trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); - auto const& stateGlobal = tsos.globalParameters(); - - std::vector hitIdx; - for (auto const& hit : seed.recHits()) { - int subid = hit.geographicalId().subdetId(); - if (subid == (int)PixelSubdetector::PixelBarrel || subid == (int)PixelSubdetector::PixelEndcap) { - const BaseTrackerRecHit* bhit = dynamic_cast(&hit); - const auto& clusterRef = bhit->firstClusterRef(); - const auto clusterKey = clusterRef.cluster_pixel().key(); - hitIdx.push_back(clusterKey); - } else { - throw cms::Exception("LSTPixelSeedInputProducer") << "Not pixel hits found!"; - } - } - - // Fill output - see_px.push_back(seedFitOk ? seedTrack.px() : 0); - see_py.push_back(seedFitOk ? seedTrack.py() : 0); - see_pz.push_back(seedFitOk ? seedTrack.pz() : 0); - see_dxy.push_back(seedFitOk ? seedTrack.dxy(bs.position()) : 0); - see_dz.push_back(seedFitOk ? seedTrack.dz(bs.position()) : 0); - see_ptErr.push_back(seedFitOk ? seedTrack.ptError() : 0); - see_etaErr.push_back(seedFitOk ? seedTrack.etaError() : 0); - see_stateTrajGlbX.push_back(stateGlobal.position().x()); - see_stateTrajGlbY.push_back(stateGlobal.position().y()); - see_stateTrajGlbZ.push_back(stateGlobal.position().z()); - see_stateTrajGlbPx.push_back(stateGlobal.momentum().x()); - see_stateTrajGlbPy.push_back(stateGlobal.momentum().y()); - see_stateTrajGlbPz.push_back(stateGlobal.momentum().z()); - see_q.push_back(seedTrack.charge()); - see_hitIdx.push_back(hitIdx); - see_seeds.push_back(seed); - } - } - - LSTPixelSeedInput pixelSeedInput(std::move(see_px), - std::move(see_py), - std::move(see_pz), - std::move(see_dxy), - std::move(see_dz), - std::move(see_ptErr), - std::move(see_etaErr), - std::move(see_stateTrajGlbX), - std::move(see_stateTrajGlbY), - std::move(see_stateTrajGlbZ), - std::move(see_stateTrajGlbPx), - std::move(see_stateTrajGlbPy), - std::move(see_stateTrajGlbPz), - std::move(see_q), - std::move(see_hitIdx)); - iEvent.emplace(lstPixelSeedInputPutToken_, std::move(pixelSeedInput)); - iEvent.emplace(lstPixelSeedsPutToken_, std::move(see_seeds)); -} - -DEFINE_FWK_MODULE(LSTPixelSeedInputProducer); diff --git a/RecoTracker/LST/plugins/alpaka/LSTInputProducer.cc b/RecoTracker/LST/plugins/alpaka/LSTInputProducer.cc new file mode 100644 index 0000000000000..6e7694901ffd6 --- /dev/null +++ b/RecoTracker/LST/plugins/alpaka/LSTInputProducer.cc @@ -0,0 +1,223 @@ +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/Event.h" +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/EventSetup.h" +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/global/EDProducer.h" +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDGetToken.h" +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDPutToken.h" +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/ESGetToken.h" +#include "HeterogeneousCore/AlpakaInterface/interface/config.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" + +#include "DataFormats/TrackerRecHit2D/interface/Phase2TrackerRecHit1D.h" + +#include "FWCore/Utilities/interface/transform.h" +#include "MagneticField/Engine/interface/MagneticField.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" +#include "DataFormats/TrackerRecHit2D/interface/SiStripMatchedRecHit2DCollection.h" +#include "DataFormats/TrajectorySeed/interface/TrajectorySeedCollection.h" +#include "DataFormats/TrackReco/interface/trackFromSeedFitFailed.h" +#include "TrackingTools/Records/interface/TransientRecHitRecord.h" +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h" +#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHitBuilder.h" + +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" +#include "RecoTracker/LSTCore/interface/LSTPrepareInput.h" + +namespace ALPAKA_ACCELERATOR_NAMESPACE { + + class LSTInputProducer : public global::EDProducer<> { + public: + LSTInputProducer(edm::ParameterSet const& iConfig); + ~LSTInputProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + private: + void produce(edm::StreamID, device::Event& iEvent, const device::EventSetup& iSetup) const override; + + const double ptCut_; + + const edm::EDGetTokenT phase2OTRecHitToken_; + + const edm::ESGetToken mfToken_; + const edm::EDGetTokenT beamSpotToken_; + const std::vector>> seedTokens_; + const edm::EDPutTokenT lstPixelSeedsPutToken_; + + const edm::EDPutTokenT lstInputPutToken_; + }; + + LSTInputProducer::LSTInputProducer(edm::ParameterSet const& iConfig) + : EDProducer<>(iConfig), + ptCut_(iConfig.getParameter("ptCut")), + phase2OTRecHitToken_(consumes(iConfig.getParameter("phase2OTRecHits"))), + mfToken_(esConsumes()), + beamSpotToken_(consumes(iConfig.getParameter("beamSpot"))), + seedTokens_( + edm::vector_transform(iConfig.getParameter>("seedTracks"), + [&](const edm::InputTag& tag) { return consumes>(tag); })), + lstPixelSeedsPutToken_(produces()), + lstInputPutToken_(produces()) {} + + void LSTInputProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("ptCut", 0.8); + + desc.add("phase2OTRecHits", edm::InputTag("siPhase2RecHits")); + + desc.add("beamSpot", edm::InputTag("offlineBeamSpot")); + desc.add>("seedTracks", + std::vector{edm::InputTag("lstInitialStepSeedTracks"), + edm::InputTag("lstHighPtTripletStepSeedTracks")}); + + descriptions.addWithDefaultLabel(desc); + } + + void LSTInputProducer::produce(edm::StreamID iID, device::Event& iEvent, const device::EventSetup& iSetup) const { + // Get the phase2OTRecHits + auto const& phase2OTHits = iEvent.get(phase2OTRecHitToken_); + + std::vector ph2_detId; + ph2_detId.reserve(phase2OTHits.dataSize()); + std::vector ph2_x; + ph2_x.reserve(phase2OTHits.dataSize()); + std::vector ph2_y; + ph2_y.reserve(phase2OTHits.dataSize()); + std::vector ph2_z; + ph2_z.reserve(phase2OTHits.dataSize()); + std::vector ph2_hits; + ph2_hits.reserve(phase2OTHits.dataSize()); + + for (auto const& it : phase2OTHits) { + const DetId hitId = it.detId(); + for (auto const& hit : it) { + ph2_detId.push_back(hitId.rawId()); + ph2_x.push_back(hit.globalPosition().x()); + ph2_y.push_back(hit.globalPosition().y()); + ph2_z.push_back(hit.globalPosition().z()); + ph2_hits.push_back(&hit); + } + } + + // Get the pixel seeds + auto const& mf = iSetup.getData(mfToken_); + auto const& bs = iEvent.get(beamSpotToken_); + + // Vector definitions + std::vector see_px; + std::vector see_py; + std::vector see_pz; + std::vector see_dxy; + std::vector see_dz; + std::vector see_ptErr; + std::vector see_etaErr; + std::vector see_stateTrajGlbX; + std::vector see_stateTrajGlbY; + std::vector see_stateTrajGlbZ; + std::vector see_stateTrajGlbPx; + std::vector see_stateTrajGlbPy; + std::vector see_stateTrajGlbPz; + std::vector see_q; + std::vector> see_hitIdx; + TrajectorySeedCollection see_seeds; + + for (auto const& seedToken : seedTokens_) { + auto const& seedTracks = iEvent.get(seedToken); + + if (seedTracks.empty()) + continue; + + // Get seed track refs + edm::RefToBaseVector seedTrackRefs; + for (edm::View::size_type i = 0; i < seedTracks.size(); ++i) { + seedTrackRefs.push_back(seedTracks.refAt(i)); + } + + edm::ProductID id = seedTracks[0].seedRef().id(); + + for (size_t iSeed = 0; iSeed < seedTrackRefs.size(); ++iSeed) { + auto const& seedTrackRef = seedTrackRefs[iSeed]; + auto const& seedTrack = *seedTrackRef; + auto const& seedRef = seedTrack.seedRef(); + auto const& seed = *seedRef; + + if (seedRef.id() != id) + throw cms::Exception("LogicError") + << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the " + "element 0 had ProductID " + << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id() << "."; + + const bool seedFitOk = !trackFromSeedFitFailed(seedTrack); + + const TrackingRecHit* lastRecHit = &*(seed.recHits().end() - 1); + TrajectoryStateOnSurface tsos = + trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &mf); + auto const& stateGlobal = tsos.globalParameters(); + + std::vector hitIdx; + for (auto const& hit : seed.recHits()) { + int subid = hit.geographicalId().subdetId(); + if (subid == (int)PixelSubdetector::PixelBarrel || subid == (int)PixelSubdetector::PixelEndcap) { + const BaseTrackerRecHit* bhit = dynamic_cast(&hit); + const auto& clusterRef = bhit->firstClusterRef(); + const auto clusterKey = clusterRef.cluster_pixel().key(); + hitIdx.push_back(clusterKey); + } else { + throw cms::Exception("LSTInputProducer") << "Not pixel hits found!"; + } + } + + // Fill output + see_px.push_back(seedFitOk ? seedTrack.px() : 0); + see_py.push_back(seedFitOk ? seedTrack.py() : 0); + see_pz.push_back(seedFitOk ? seedTrack.pz() : 0); + see_dxy.push_back(seedFitOk ? seedTrack.dxy(bs.position()) : 0); + see_dz.push_back(seedFitOk ? seedTrack.dz(bs.position()) : 0); + see_ptErr.push_back(seedFitOk ? seedTrack.ptError() : 0); + see_etaErr.push_back(seedFitOk ? seedTrack.etaError() : 0); + see_stateTrajGlbX.push_back(stateGlobal.position().x()); + see_stateTrajGlbY.push_back(stateGlobal.position().y()); + see_stateTrajGlbZ.push_back(stateGlobal.position().z()); + see_stateTrajGlbPx.push_back(stateGlobal.momentum().x()); + see_stateTrajGlbPy.push_back(stateGlobal.momentum().y()); + see_stateTrajGlbPz.push_back(stateGlobal.momentum().z()); + see_q.push_back(seedTrack.charge()); + see_hitIdx.emplace_back(std::move(hitIdx)); + see_seeds.push_back(seed); + } + } + + auto lstInputHC = lst::prepareInput(see_px, + see_py, + see_pz, + see_dxy, + see_dz, + see_ptErr, + see_etaErr, + see_stateTrajGlbX, + see_stateTrajGlbY, + see_stateTrajGlbZ, + see_stateTrajGlbPx, + see_stateTrajGlbPy, + see_stateTrajGlbPz, + see_q, + see_hitIdx, + {}, + ph2_detId, + ph2_x, + ph2_y, + ph2_z, + ph2_hits, + ptCut_, + iEvent.queue()); + + iEvent.emplace(lstInputPutToken_, std::move(lstInputHC)); + iEvent.emplace(lstPixelSeedsPutToken_, std::move(see_seeds)); + } + +} // namespace ALPAKA_ACCELERATOR_NAMESPACE + +#include "HeterogeneousCore/AlpakaCore/interface/alpaka/MakerMacros.h" +DEFINE_FWK_ALPAKA_MODULE(LSTInputProducer); diff --git a/RecoTracker/LST/plugins/alpaka/LSTProducer.cc b/RecoTracker/LST/plugins/alpaka/LSTProducer.cc index 9a8889c1a6a91..48f4ac9bb2366 100644 --- a/RecoTracker/LST/plugins/alpaka/LSTProducer.cc +++ b/RecoTracker/LST/plugins/alpaka/LSTProducer.cc @@ -16,8 +16,6 @@ #include "HeterogeneousCore/AlpakaInterface/interface/config.h" #include "RecoTracker/LST/interface/LSTOutput.h" -#include "RecoTracker/LST/interface/LSTPhase2OTHitsInput.h" -#include "RecoTracker/LST/interface/LSTPixelSeedInput.h" #include "RecoTracker/Record/interface/TrackerRecoGeometryRecord.h" @@ -27,8 +25,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE { public: LSTProducer(edm::ParameterSet const& config) : SynchronizingEDProducer(config), - lstPixelSeedInputToken_{consumes(config.getParameter("pixelSeedInput"))}, - lstPhase2OTHitsInputToken_{consumes(config.getParameter("phase2OTHitsInput"))}, + lstInputToken_{consumes(config.getParameter("lstInput"))}, lstESToken_{esConsumes(edm::ESInputTag("", config.getParameter("ptCutLabel")))}, verbose_(config.getParameter("verbose")), ptCut_(config.getParameter("ptCut")), @@ -38,8 +35,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE { void acquire(device::Event const& event, device::EventSetup const& setup) override { // Inputs - auto const& pixelSeeds = event.get(lstPixelSeedInputToken_); - auto const& phase2OTHits = event.get(lstPhase2OTHitsInputToken_); + auto const& lstInputDC = event.get(lstInputToken_); auto const& lstESDeviceData = setup.getData(lstESToken_); @@ -47,25 +43,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE { verbose_, static_cast(ptCut_), &lstESDeviceData, - pixelSeeds.px(), - pixelSeeds.py(), - pixelSeeds.pz(), - pixelSeeds.dxy(), - pixelSeeds.dz(), - pixelSeeds.ptErr(), - pixelSeeds.etaErr(), - pixelSeeds.stateTrajGlbX(), - pixelSeeds.stateTrajGlbY(), - pixelSeeds.stateTrajGlbZ(), - pixelSeeds.stateTrajGlbPx(), - pixelSeeds.stateTrajGlbPy(), - pixelSeeds.stateTrajGlbPz(), - pixelSeeds.q(), - pixelSeeds.hitIdx(), - phase2OTHits.detId(), - phase2OTHits.x(), - phase2OTHits.y(), - phase2OTHits.z(), + &lstInputDC, nopLSDupClean_, tcpLSTriplets_); } @@ -78,8 +56,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE { static void fillDescriptions(edm::ConfigurationDescriptions& descriptions) { edm::ParameterSetDescription desc; - desc.add("pixelSeedInput", edm::InputTag{"lstPixelSeedInputProducer"}); - desc.add("phase2OTHitsInput", edm::InputTag{"lstPhase2OTHitsInputProducer"}); + desc.add("lstInput", edm::InputTag{"lstInputProducer"}); desc.add("verbose", false); desc.add("ptCut", 0.8); desc.add("ptCutLabel", "0.8"); @@ -89,8 +66,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE { } private: - edm::EDGetTokenT lstPixelSeedInputToken_; - edm::EDGetTokenT lstPhase2OTHitsInputToken_; + device::EDGetToken lstInputToken_; device::ESGetToken, TrackerRecoGeometryRecord> lstESToken_; const bool verbose_; const double ptCut_; diff --git a/RecoTracker/LST/python/lst_cff.py b/RecoTracker/LST/python/lst_cff.py index af3a80ae77e18..d7fd2bec946a5 100644 --- a/RecoTracker/LST/python/lst_cff.py +++ b/RecoTracker/LST/python/lst_cff.py @@ -1,6 +1,5 @@ import FWCore.ParameterSet.Config as cms from RecoTracker.LST.lstSeedTracks_cff import * -from RecoTracker.LST.lstPixelSeedInputProducer_cfi import * -from RecoTracker.LST.lstPhase2OTHitsInputProducer_cfi import * +from RecoTracker.LST.lstInputProducer_cfi import * from RecoTracker.LST.lstOutputConverter_cfi import * diff --git a/RecoTracker/LST/src/classes.h b/RecoTracker/LST/src/classes.h index 6a6817d9b538e..5cf7a0760d36d 100644 --- a/RecoTracker/LST/src/classes.h +++ b/RecoTracker/LST/src/classes.h @@ -2,8 +2,6 @@ #define RecoTracker_LST_classes_h #include "DataFormats/Common/interface/Wrapper.h" -#include "RecoTracker/LST/interface/LSTPixelSeedInput.h" -#include "RecoTracker/LST/interface/LSTPhase2OTHitsInput.h" #include "RecoTracker/LST/interface/LSTOutput.h" #endif diff --git a/RecoTracker/LST/src/classes_def.xml b/RecoTracker/LST/src/classes_def.xml index d386e7b92a215..7bb6c25d07968 100644 --- a/RecoTracker/LST/src/classes_def.xml +++ b/RecoTracker/LST/src/classes_def.xml @@ -1,10 +1,4 @@ - - - - - - diff --git a/RecoTracker/LSTCore/BuildFile.xml b/RecoTracker/LSTCore/BuildFile.xml index df9ca5e7c34bb..e9cbb2cccf046 100644 --- a/RecoTracker/LSTCore/BuildFile.xml +++ b/RecoTracker/LSTCore/BuildFile.xml @@ -2,6 +2,8 @@ + + diff --git a/RecoTracker/LSTCore/interface/Common.h b/RecoTracker/LSTCore/interface/Common.h index 5f96da2773f15..66d184f59902d 100644 --- a/RecoTracker/LSTCore/interface/Common.h +++ b/RecoTracker/LSTCore/interface/Common.h @@ -64,6 +64,7 @@ namespace lst { }; struct Params_pLS { static constexpr int kLayers = 2, kHits = 4; + using ArrayUxHits = edm::StdArray; }; struct Params_LS { static constexpr int kLayers = 2, kHits = 4; diff --git a/RecoTracker/LSTCore/interface/HitsHostCollection.h b/RecoTracker/LSTCore/interface/HitsHostCollection.h index f26c98c36e069..84255c9240185 100644 --- a/RecoTracker/LSTCore/interface/HitsHostCollection.h +++ b/RecoTracker/LSTCore/interface/HitsHostCollection.h @@ -5,6 +5,6 @@ #include "DataFormats/Portable/interface/PortableHostCollection.h" namespace lst { - using HitsHostCollection = PortableHostMultiCollection; + using HitsHostCollection = PortableHostMultiCollection; } // namespace lst #endif diff --git a/RecoTracker/LSTCore/interface/HitsSoA.h b/RecoTracker/LSTCore/interface/HitsSoA.h index d26fe61963a0d..93b51bbfb70de 100644 --- a/RecoTracker/LSTCore/interface/HitsSoA.h +++ b/RecoTracker/LSTCore/interface/HitsSoA.h @@ -8,13 +8,8 @@ namespace lst { - GENERATE_SOA_LAYOUT(HitsSoALayout, - SOA_COLUMN(float, xs), - SOA_COLUMN(float, ys), - SOA_COLUMN(float, zs), + GENERATE_SOA_LAYOUT(HitsExtendedSoALayout, SOA_COLUMN(uint16_t, moduleIndices), - SOA_COLUMN(unsigned int, idxs), - SOA_COLUMN(unsigned int, detid), SOA_COLUMN(float, rts), SOA_COLUMN(float, phis), SOA_COLUMN(float, etas), @@ -30,11 +25,11 @@ namespace lst { SOA_COLUMN(int16_t, hitRangesnLower), SOA_COLUMN(int16_t, hitRangesnUpper)) - using HitsSoA = HitsSoALayout<>; + using HitsExtendedSoA = HitsExtendedSoALayout<>; using HitsRangesSoA = HitsRangesSoALayout<>; - using Hits = HitsSoA::View; - using HitsConst = HitsSoA::ConstView; + using HitsExtended = HitsExtendedSoA::View; + using HitsExtendedConst = HitsExtendedSoA::ConstView; using HitsRanges = HitsRangesSoA::View; using HitsRangesConst = HitsRangesSoA::ConstView; diff --git a/RecoTracker/LSTCore/interface/LSTInputHostCollection.h b/RecoTracker/LSTCore/interface/LSTInputHostCollection.h new file mode 100644 index 0000000000000..f9ea02e289769 --- /dev/null +++ b/RecoTracker/LSTCore/interface/LSTInputHostCollection.h @@ -0,0 +1,12 @@ +#ifndef RecoTracker_LSTCore_interface_LSTInputHostCollection_h +#define RecoTracker_LSTCore_interface_LSTInputHostCollection_h + +#include "RecoTracker/LSTCore/interface/LSTInputSoA.h" +#include "DataFormats/Portable/interface/PortableHostCollection.h" +#include "DataFormats/Portable/interface/PortableDeviceCollection.h" + +namespace lst { + using LSTInputHostCollection = PortableHostMultiCollection; +} // namespace lst + +#endif diff --git a/RecoTracker/LSTCore/interface/LSTInputSoA.h b/RecoTracker/LSTCore/interface/LSTInputSoA.h new file mode 100644 index 0000000000000..1b55d7334c515 --- /dev/null +++ b/RecoTracker/LSTCore/interface/LSTInputSoA.h @@ -0,0 +1,54 @@ +#ifndef RecoTracker_LSTCore_interface_LSTInputSoA_h +#define RecoTracker_LSTCore_interface_LSTInputSoA_h + +#ifndef LST_STANDALONE +#include "DataFormats/TrackingRecHit/interface/TrackingRecHit.h" +#endif + +#include "DataFormats/SoATemplate/interface/SoALayout.h" +#include "DataFormats/Portable/interface/PortableCollection.h" + +#include "RecoTracker/LSTCore/interface/Common.h" + +namespace lst { + + GENERATE_SOA_LAYOUT(HitsBaseSoALayout, + SOA_COLUMN(float, xs), + SOA_COLUMN(float, ys), + SOA_COLUMN(float, zs), + SOA_COLUMN(unsigned int, idxs), + SOA_COLUMN(unsigned int, detid) +#ifndef LST_STANDALONE + , + SOA_COLUMN(TrackingRecHit const*, hits) +#endif + ) + + GENERATE_SOA_LAYOUT(PixelSeedsSoALayout, + SOA_COLUMN(Params_pLS::ArrayUxHits, hitIndices), + SOA_COLUMN(float, deltaPhi), + SOA_COLUMN(unsigned int, seedIdx), + SOA_COLUMN(int, charge), + SOA_COLUMN(int, superbin), + SOA_COLUMN(PixelType, pixelType), + SOA_COLUMN(char, isQuad), + SOA_COLUMN(float, ptIn), + SOA_COLUMN(float, ptErr), + SOA_COLUMN(float, px), + SOA_COLUMN(float, py), + SOA_COLUMN(float, pz), + SOA_COLUMN(float, etaErr), + SOA_COLUMN(float, eta), + SOA_COLUMN(float, phi)) + + using HitsBaseSoA = HitsBaseSoALayout<>; + using PixelSeedsSoA = PixelSeedsSoALayout<>; + + using HitsBase = HitsBaseSoA::View; + using HitsBaseConst = HitsBaseSoA::ConstView; + using PixelSeeds = PixelSeedsSoA::View; + using PixelSeedsConst = PixelSeedsSoA::ConstView; + +} // namespace lst + +#endif diff --git a/RecoTracker/LSTCore/interface/LSTPrepareInput.h b/RecoTracker/LSTCore/interface/LSTPrepareInput.h new file mode 100644 index 0000000000000..423272c76ecc9 --- /dev/null +++ b/RecoTracker/LSTCore/interface/LSTPrepareInput.h @@ -0,0 +1,253 @@ +#ifndef RecoTracker_LSTCore_interface_LSTPrepareInput_h +#define RecoTracker_LSTCore_interface_LSTPrepareInput_h + +#include +#include +#include + +#include "RecoTracker/LSTCore/interface/Common.h" +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" + +namespace lst { + + inline ROOT::Math::XYZVector calculateR3FromPCA(const ROOT::Math::XYZVector& p3, float dxy, float dz) { + const float pt = p3.rho(); + const float p = p3.r(); + const float vz = dz * pt * pt / p / p; + + const float vx = -dxy * p3.y() / pt - p3.x() / p * p3.z() / p * dz; + const float vy = dxy * p3.x() / pt - p3.y() / p * p3.z() / p * dz; + return {vx, vy, vz}; + } + + template + inline LSTInputHostCollection prepareInput(std::vector const& see_px, + std::vector const& see_py, + std::vector const& see_pz, + std::vector const& see_dxy, + std::vector const& see_dz, + std::vector const& see_ptErr, + std::vector const& see_etaErr, + std::vector const& see_stateTrajGlbX, + std::vector const& see_stateTrajGlbY, + std::vector const& see_stateTrajGlbZ, + std::vector const& see_stateTrajGlbPx, + std::vector const& see_stateTrajGlbPy, + std::vector const& see_stateTrajGlbPz, + std::vector const& see_q, + std::vector> const& see_hitIdx, + std::vector const& see_algo, + std::vector const& ph2_detId, + std::vector const& ph2_x, + std::vector const& ph2_y, + std::vector const& ph2_z, +#ifndef LST_STANDALONE + std::vector const& ph2_hits, +#endif + float const ptCut, + TQueue const& queue) { + std::vector trkX; + std::vector trkY; + std::vector trkZ; + std::vector hitId; + std::vector hitIdxs; + std::vector hitIndices_vec; + std::vector deltaPhi_vec; + std::vector ptIn_vec; + std::vector ptErr_vec; + std::vector px_vec; + std::vector py_vec; + std::vector pz_vec; + std::vector eta_vec; + std::vector etaErr_vec; + std::vector phi_vec; + std::vector charge_vec; + std::vector seedIdx_vec; + std::vector superbin_vec; + std::vector pixelType_vec; + std::vector isQuad_vec; + + const int hit_size = ph2_x.size(); + + unsigned int count = 0; + auto n_see = see_stateTrajGlbPx.size(); + px_vec.reserve(n_see); + py_vec.reserve(n_see); + pz_vec.reserve(n_see); + hitIndices_vec.reserve(n_see); + ptIn_vec.reserve(n_see); + ptErr_vec.reserve(n_see); + etaErr_vec.reserve(n_see); + eta_vec.reserve(n_see); + phi_vec.reserve(n_see); + charge_vec.reserve(n_see); + seedIdx_vec.reserve(n_see); + deltaPhi_vec.reserve(n_see); + trkX.reserve(4 * n_see); + trkY.reserve(4 * n_see); + trkZ.reserve(4 * n_see); + hitId.reserve(4 * n_see); + hitIdxs.reserve(hit_size + 4 * n_see); + hitIdxs.resize(hit_size); + + std::iota(hitIdxs.begin(), hitIdxs.end(), 0); + + for (size_t iSeed = 0; iSeed < n_see; iSeed++) { + // Only needed for standalone + bool good_seed_type = see_algo.empty() || see_algo[iSeed] == 4 || see_algo[iSeed] == 22; + if (!good_seed_type) + continue; + + ROOT::Math::XYZVector p3LH(see_stateTrajGlbPx[iSeed], see_stateTrajGlbPy[iSeed], see_stateTrajGlbPz[iSeed]); + float ptIn = p3LH.rho(); + float eta = p3LH.eta(); + float ptErr = see_ptErr[iSeed]; + + if ((ptIn > ptCut - 2 * ptErr)) { + ROOT::Math::XYZVector r3LH(see_stateTrajGlbX[iSeed], see_stateTrajGlbY[iSeed], see_stateTrajGlbZ[iSeed]); + ROOT::Math::XYZVector p3PCA(see_px[iSeed], see_py[iSeed], see_pz[iSeed]); + ROOT::Math::XYZVector r3PCA(calculateR3FromPCA(p3PCA, see_dxy[iSeed], see_dz[iSeed])); + + // The charge could be used directly in the line below + float pixelSegmentDeltaPhiChange = ROOT::Math::VectorUtil::DeltaPhi(p3LH, r3LH); + float etaErr = see_etaErr[iSeed]; + float px = p3LH.x(); + float py = p3LH.y(); + float pz = p3LH.z(); + + int charge = see_q[iSeed]; + PixelType pixtype = PixelType::kInvalid; + + if (ptIn >= 2.0) + pixtype = PixelType::kHighPt; + else if (ptIn >= (ptCut - 2 * ptErr) and ptIn < 2.0) { + if (pixelSegmentDeltaPhiChange >= 0) + pixtype = PixelType::kLowPtPosCurv; + else + pixtype = PixelType::kLowPtNegCurv; + } else + continue; + + unsigned int hitIdx0 = hit_size + count; + count++; + unsigned int hitIdx1 = hit_size + count; + count++; + unsigned int hitIdx2 = hit_size + count; + count++; + unsigned int hitIdx3; + if (see_hitIdx[iSeed].size() <= 3) + hitIdx3 = hitIdx2; + else { + hitIdx3 = hit_size + count; + count++; + } + + trkX.push_back(r3PCA.x()); + trkY.push_back(r3PCA.y()); + trkZ.push_back(r3PCA.z()); + trkX.push_back(p3PCA.rho()); + float p3PCA_Eta = p3PCA.eta(); + trkY.push_back(p3PCA_Eta); + float p3PCA_Phi = p3PCA.phi(); + trkZ.push_back(p3PCA_Phi); + trkX.push_back(r3LH.x()); + trkY.push_back(r3LH.y()); + trkZ.push_back(r3LH.z()); + hitId.push_back(1); + hitId.push_back(1); + hitId.push_back(1); + if (see_hitIdx[iSeed].size() > 3) { + trkX.push_back(r3LH.x()); + trkY.push_back(see_dxy[iSeed]); + trkZ.push_back(see_dz[iSeed]); + hitId.push_back(1); + } + px_vec.push_back(px); + py_vec.push_back(py); + pz_vec.push_back(pz); + + hitIndices_vec.push_back({{hitIdx0, hitIdx1, hitIdx2, hitIdx3}}); + ptIn_vec.push_back(ptIn); + ptErr_vec.push_back(ptErr); + etaErr_vec.push_back(etaErr); + eta_vec.push_back(eta); + float phi = p3LH.phi(); + phi_vec.push_back(phi); + charge_vec.push_back(charge); + seedIdx_vec.push_back(iSeed); + deltaPhi_vec.push_back(pixelSegmentDeltaPhiChange); + + hitIdxs.push_back(see_hitIdx[iSeed][0]); + hitIdxs.push_back(see_hitIdx[iSeed][1]); + hitIdxs.push_back(see_hitIdx[iSeed][2]); + char isQuad = false; + if (see_hitIdx[iSeed].size() > 3) { + isQuad = true; + hitIdxs.push_back(see_hitIdx[iSeed][3]); + } + float neta = 25.; + float nphi = 72.; + float nz = 25.; + int etabin = (p3PCA_Eta + 2.6) / ((2 * 2.6) / neta); + int phibin = (p3PCA_Phi + std::numbers::pi_v) / ((2. * std::numbers::pi_v) / nphi); + int dzbin = (std::clamp(see_dz[iSeed], -30.f, 30.f) + 30) / (2 * 30 / nz); + int isuperbin = (nz * nphi) * etabin + (nz)*phibin + dzbin; + superbin_vec.push_back(isuperbin); + pixelType_vec.push_back(pixtype); + isQuad_vec.push_back(isQuad); + } + } + + // Build the SoAs + int nHitsOT = ph2_x.size(); + int nHitsIT = trkX.size(); + int nPixelSeeds = ptIn_vec.size(); + if (static_cast(nPixelSeeds) > n_max_pixel_segments_per_module) { + nPixelSeeds = n_max_pixel_segments_per_module; + } + + std::array const soa_sizes{{nHitsIT + nHitsOT, nPixelSeeds}}; + LSTInputHostCollection lstInputHC(soa_sizes, queue); + + auto hits = lstInputHC.view(); + std::memcpy(hits.xs(), ph2_x.data(), nHitsOT * sizeof(float)); + std::memcpy(hits.ys(), ph2_y.data(), nHitsOT * sizeof(float)); + std::memcpy(hits.zs(), ph2_z.data(), nHitsOT * sizeof(float)); + std::memcpy(hits.detid(), ph2_detId.data(), nHitsOT * sizeof(unsigned int)); +#ifndef LST_STANDALONE + std::memcpy(hits.hits(), ph2_hits.data(), nHitsOT * sizeof(TrackingRecHit const*)); +#endif + + std::memcpy(hits.xs() + nHitsOT, trkX.data(), nHitsIT * sizeof(float)); + std::memcpy(hits.ys() + nHitsOT, trkY.data(), nHitsIT * sizeof(float)); + std::memcpy(hits.zs() + nHitsOT, trkZ.data(), nHitsIT * sizeof(float)); + std::memcpy(hits.detid() + nHitsOT, hitId.data(), nHitsIT * sizeof(unsigned int)); +#ifndef LST_STANDALONE + std::memset(hits.hits() + nHitsOT, 0, nHitsIT * sizeof(TrackingRecHit const*)); +#endif + + std::memcpy(hits.idxs(), hitIdxs.data(), (nHitsIT + nHitsOT) * sizeof(unsigned int)); + + auto pixelSeeds = lstInputHC.view(); + std::memcpy(pixelSeeds.hitIndices(), hitIndices_vec.data(), nPixelSeeds * sizeof(Params_pLS::ArrayUxHits)); + std::memcpy(pixelSeeds.deltaPhi(), deltaPhi_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.ptIn(), ptIn_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.ptErr(), ptErr_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.px(), px_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.py(), py_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.pz(), pz_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.etaErr(), etaErr_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.isQuad(), isQuad_vec.data(), nPixelSeeds * sizeof(char)); + std::memcpy(pixelSeeds.eta(), eta_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.phi(), phi_vec.data(), nPixelSeeds * sizeof(float)); + std::memcpy(pixelSeeds.charge(), charge_vec.data(), nPixelSeeds * sizeof(int)); + std::memcpy(pixelSeeds.seedIdx(), seedIdx_vec.data(), nPixelSeeds * sizeof(unsigned int)); + std::memcpy(pixelSeeds.superbin(), superbin_vec.data(), nPixelSeeds * sizeof(int)); + std::memcpy(pixelSeeds.pixelType(), pixelType_vec.data(), nPixelSeeds * sizeof(PixelType)); + + return lstInputHC; + } + +} // namespace lst + +#endif diff --git a/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h b/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h index 70e2db3f8ce64..3df0647d1669b 100644 --- a/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h +++ b/RecoTracker/LSTCore/interface/PixelSegmentsSoA.h @@ -9,22 +9,9 @@ namespace lst { GENERATE_SOA_LAYOUT(PixelSegmentsSoALayout, - SOA_COLUMN(unsigned int, seedIdx), - SOA_COLUMN(int, charge), - SOA_COLUMN(int, superbin), SOA_COLUMN(uint4, pLSHitsIdxs), - SOA_COLUMN(PixelType, pixelType), - SOA_COLUMN(char, isQuad), SOA_COLUMN(char, isDup), SOA_COLUMN(bool, partOfPT5), - SOA_COLUMN(float, ptIn), - SOA_COLUMN(float, ptErr), - SOA_COLUMN(float, px), - SOA_COLUMN(float, py), - SOA_COLUMN(float, pz), - SOA_COLUMN(float, etaErr), - SOA_COLUMN(float, eta), - SOA_COLUMN(float, phi), SOA_COLUMN(float, score), SOA_COLUMN(float, circleCenterX), SOA_COLUMN(float, circleCenterY), diff --git a/RecoTracker/LSTCore/interface/alpaka/HitsDeviceCollection.h b/RecoTracker/LSTCore/interface/alpaka/HitsDeviceCollection.h index 5bafd9df246bc..b2f96601f7f5b 100644 --- a/RecoTracker/LSTCore/interface/alpaka/HitsDeviceCollection.h +++ b/RecoTracker/LSTCore/interface/alpaka/HitsDeviceCollection.h @@ -7,7 +7,7 @@ #include "RecoTracker/LSTCore/interface/HitsSoA.h" namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { - using HitsDeviceCollection = PortableCollection2; + using HitsDeviceCollection = PortableCollection2; } // namespace ALPAKA_ACCELERATOR_NAMESPACE::lst #endif diff --git a/RecoTracker/LSTCore/interface/alpaka/LST.h b/RecoTracker/LSTCore/interface/alpaka/LST.h index 5fe369b9cd22b..ebaae0f2c1a8a 100644 --- a/RecoTracker/LSTCore/interface/alpaka/LST.h +++ b/RecoTracker/LSTCore/interface/alpaka/LST.h @@ -3,6 +3,7 @@ #include "RecoTracker/LSTCore/interface/alpaka/Common.h" #include "RecoTracker/LSTCore/interface/LSTESData.h" +#include "RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h" #include #include @@ -19,25 +20,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { bool verbose, const float ptCut, LSTESData const* deviceESData, - std::vector const& see_px, - std::vector const& see_py, - std::vector const& see_pz, - std::vector const& see_dxy, - std::vector const& see_dz, - std::vector const& see_ptErr, - std::vector const& see_etaErr, - std::vector const& see_stateTrajGlbX, - std::vector const& see_stateTrajGlbY, - std::vector const& see_stateTrajGlbZ, - std::vector const& see_stateTrajGlbPx, - std::vector const& see_stateTrajGlbPy, - std::vector const& see_stateTrajGlbPz, - std::vector const& see_q, - std::vector> const& see_hitIdx, - std::vector const& ph2_detId, - std::vector const& ph2_x, - std::vector const& ph2_y, - std::vector const& ph2_z, + LSTInputDeviceCollection const* lstInputDC, bool no_pls_dupclean, bool tc_pls_triplets); std::vector> const& hits() const { return out_tc_hitIdxs_; } @@ -46,53 +29,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { std::vector const& trackCandidateType() const { return out_tc_trackCandidateType_; } private: - void prepareInput(std::vector const& see_px, - std::vector const& see_py, - std::vector const& see_pz, - std::vector const& see_dxy, - std::vector const& see_dz, - std::vector const& see_ptErr, - std::vector const& see_etaErr, - std::vector const& see_stateTrajGlbX, - std::vector const& see_stateTrajGlbY, - std::vector const& see_stateTrajGlbZ, - std::vector const& see_stateTrajGlbPx, - std::vector const& see_stateTrajGlbPy, - std::vector const& see_stateTrajGlbPz, - std::vector const& see_q, - std::vector> const& see_hitIdx, - std::vector const& ph2_detId, - std::vector const& ph2_x, - std::vector const& ph2_y, - std::vector const& ph2_z, - const float ptCut); - void getOutput(LSTEvent& event); - // Input and output vectors - std::vector in_trkX_; - std::vector in_trkY_; - std::vector in_trkZ_; - std::vector in_hitId_; - std::vector in_hitIdxs_; - std::vector in_hitIndices_vec0_; - std::vector in_hitIndices_vec1_; - std::vector in_hitIndices_vec2_; - std::vector in_hitIndices_vec3_; - std::vector in_deltaPhi_vec_; - std::vector in_ptIn_vec_; - std::vector in_ptErr_vec_; - std::vector in_px_vec_; - std::vector in_py_vec_; - std::vector in_pz_vec_; - std::vector in_eta_vec_; - std::vector in_etaErr_vec_; - std::vector in_phi_vec_; - std::vector in_charge_vec_; - std::vector in_seedIdx_vec_; - std::vector in_superbin_vec_; - std::vector in_pixelType_vec_; - std::vector in_isQuad_vec_; + // Output vectors std::vector> out_tc_hitIdxs_; std::vector out_tc_len_; std::vector out_tc_seedIdx_; diff --git a/RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h b/RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h new file mode 100644 index 0000000000000..af8ebe0ee654c --- /dev/null +++ b/RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h @@ -0,0 +1,13 @@ +#ifndef RecoTracker_LSTCore_interface_alpaka_LSTInputDeviceCollection_h +#define RecoTracker_LSTCore_interface_alpaka_LSTInputDeviceCollection_h + +#include "DataFormats/Portable/interface/alpaka/PortableCollection.h" + +#include "RecoTracker/LSTCore/interface/alpaka/Common.h" +#include "RecoTracker/LSTCore/interface/LSTInputSoA.h" + +namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { + using LSTInputDeviceCollection = PortableCollection2; +} // namespace ALPAKA_ACCELERATOR_NAMESPACE::lst + +#endif diff --git a/RecoTracker/LSTCore/src/alpaka/Hit.h b/RecoTracker/LSTCore/src/alpaka/Hit.h index 92fed6a4cb85e..6ef8e4330fdda 100644 --- a/RecoTracker/LSTCore/src/alpaka/Hit.h +++ b/RecoTracker/LSTCore/src/alpaka/Hit.h @@ -43,30 +43,33 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int nEndCapMap, // Number of elements in endcap map EndcapGeometryDevConst endcapGeometry, ModulesConst modules, - Hits hits, - HitsRanges hitsRanges, - unsigned int nHits) const // Total number of hits in event + HitsBaseConst hitsBase, + HitsExtended hitsExtended, + HitsRanges hitsRanges) const // Total number of hits in event { auto geoMapDetId = endcapGeometry.geoMapDetId(); // DetId's from endcap map auto geoMapPhi = endcapGeometry.geoMapPhi(); // Phi values from endcap map + int nHits = hitsExtended.metadata().size(); + ALPAKA_ASSERT_ACC(nHits == hitsBase.metadata().size()); for (unsigned int ihit : cms::alpakatools::uniform_elements(acc, nHits)) { - float ihit_x = hits.xs()[ihit]; - float ihit_y = hits.ys()[ihit]; - float ihit_z = hits.zs()[ihit]; - int iDetId = hits.detid()[ihit]; + float ihit_x = hitsBase.xs()[ihit]; + float ihit_y = hitsBase.ys()[ihit]; + float ihit_z = hitsBase.zs()[ihit]; + int iDetId = hitsBase.detid()[ihit]; - hits.rts()[ihit] = alpaka::math::sqrt(acc, ihit_x * ihit_x + ihit_y * ihit_y); - hits.phis()[ihit] = cms::alpakatools::phi(acc, ihit_x, ihit_y); - hits.etas()[ihit] = + hitsExtended.rts()[ihit] = alpaka::math::sqrt(acc, ihit_x * ihit_x + ihit_y * ihit_y); + hitsExtended.phis()[ihit] = cms::alpakatools::phi(acc, ihit_x, ihit_y); + hitsExtended.etas()[ihit] = ((ihit_z > 0) - (ihit_z < 0)) * - alpaka::math::acosh( - acc, alpaka::math::sqrt(acc, ihit_x * ihit_x + ihit_y * ihit_y + ihit_z * ihit_z) / hits.rts()[ihit]); + alpaka::math::acosh(acc, + alpaka::math::sqrt(acc, ihit_x * ihit_x + ihit_y * ihit_y + ihit_z * ihit_z) / + hitsExtended.rts()[ihit]); auto found_pointer = alpaka_std::lower_bound(modules.mapdetId(), modules.mapdetId() + nModules, iDetId); ALPAKA_ASSERT_ACC(found_pointer != modules.mapdetId() + nModules); int found_index = std::distance(modules.mapdetId(), found_pointer); uint16_t lastModuleIndex = modules.mapIdx()[found_index]; - hits.moduleIndices()[ihit] = lastModuleIndex; + hitsExtended.moduleIndices()[ihit] = lastModuleIndex; if (modules.subdets()[lastModuleIndex] == Endcap && modules.moduleType()[lastModuleIndex] == TwoS) { found_pointer = alpaka_std::lower_bound(geoMapDetId, geoMapDetId + nEndCapMap, iDetId); @@ -74,11 +77,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { found_index = std::distance(geoMapDetId, found_pointer); float phi = geoMapPhi[found_index]; float cos_phi = alpaka::math::cos(acc, phi); - hits.highEdgeXs()[ihit] = ihit_x + 2.5f * cos_phi; - hits.lowEdgeXs()[ihit] = ihit_x - 2.5f * cos_phi; + hitsExtended.highEdgeXs()[ihit] = ihit_x + 2.5f * cos_phi; + hitsExtended.lowEdgeXs()[ihit] = ihit_x - 2.5f * cos_phi; float sin_phi = alpaka::math::sin(acc, phi); - hits.highEdgeYs()[ihit] = ihit_y + 2.5f * sin_phi; - hits.lowEdgeYs()[ihit] = ihit_y - 2.5f * sin_phi; + hitsExtended.highEdgeYs()[ihit] = ihit_y + 2.5f * sin_phi; + hitsExtended.lowEdgeYs()[ihit] = ihit_y - 2.5f * sin_phi; } // Need to set initial value if index hasn't been seen before. int old = alpaka::atomicCas(acc, diff --git a/RecoTracker/LSTCore/src/alpaka/Kernels.h b/RecoTracker/LSTCore/src/alpaka/Kernels.h index 42709c6275d6d..62e5d12fc1fd0 100644 --- a/RecoTracker/LSTCore/src/alpaka/Kernels.h +++ b/RecoTracker/LSTCore/src/alpaka/Kernels.h @@ -322,6 +322,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(Acc2D const& acc, ModulesConst modules, SegmentsOccupancyConst segmentsOccupancy, + PixelSeedsConst pixelSeeds, PixelSegments pixelSegments, bool secondpass) const { int pixelModuleIndex = modules.nLowerModules(); @@ -331,7 +332,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { nPixelSegments = n_max_pixel_segments_per_module; for (unsigned int ix : cms::alpakatools::uniform_elements_y(acc, nPixelSegments)) { - if (secondpass && (!pixelSegments.isQuad()[ix] || (pixelSegments.isDup()[ix] & 1))) + if (secondpass && (!pixelSeeds.isQuad()[ix] || (pixelSegments.isDup()[ix] & 1))) continue; unsigned int phits1[Params_pLS::kHits]; @@ -339,20 +340,20 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { phits1[1] = pixelSegments.pLSHitsIdxs()[ix].y; phits1[2] = pixelSegments.pLSHitsIdxs()[ix].z; phits1[3] = pixelSegments.pLSHitsIdxs()[ix].w; - float eta_pix1 = pixelSegments.eta()[ix]; - float phi_pix1 = pixelSegments.phi()[ix]; + float eta_pix1 = pixelSeeds.eta()[ix]; + float phi_pix1 = pixelSeeds.phi()[ix]; for (unsigned int jx : cms::alpakatools::uniform_elements_x(acc, ix + 1, nPixelSegments)) { - float eta_pix2 = pixelSegments.eta()[jx]; - float phi_pix2 = pixelSegments.phi()[jx]; + float eta_pix2 = pixelSeeds.eta()[jx]; + float phi_pix2 = pixelSeeds.phi()[jx]; if (alpaka::math::abs(acc, eta_pix2 - eta_pix1) > 0.1f) continue; - if (secondpass && (!pixelSegments.isQuad()[jx] || (pixelSegments.isDup()[jx] & 1))) + if (secondpass && (!pixelSeeds.isQuad()[jx] || (pixelSegments.isDup()[jx] & 1))) continue; - int8_t quad_diff = pixelSegments.isQuad()[ix] - pixelSegments.isQuad()[jx]; + int8_t quad_diff = pixelSeeds.isQuad()[ix] - pixelSeeds.isQuad()[jx]; float score_diff = pixelSegments.score()[ix] - pixelSegments.score()[jx]; // Always keep quads over trips. If they are the same, we want the object with better score int idxToRemove; diff --git a/RecoTracker/LSTCore/src/alpaka/LST.cc b/RecoTracker/LSTCore/src/alpaka/LST.cc index 94545c7172a20..8d6a0c99f3995 100644 --- a/RecoTracker/LSTCore/src/alpaka/LST.cc +++ b/RecoTracker/LSTCore/src/alpaka/LST.cc @@ -9,16 +9,6 @@ using namespace ALPAKA_ACCELERATOR_NAMESPACE::lst; using XYZVector = ROOT::Math::XYZVector; namespace { - XYZVector calculateR3FromPCA(const XYZVector& p3, float dxy, float dz) { - const float pt = p3.rho(); - const float p = p3.r(); - const float vz = dz * pt * pt / p / p; - - const float vx = -dxy * p3.y() / pt - p3.x() / p * p3.z() / p * dz; - const float vy = dxy * p3.x() / pt - p3.y() / p * p3.z() / p * dz; - return {vx, vy, vz}; - } - using namespace ALPAKA_ACCELERATOR_NAMESPACE::lst; std::vector getHitIdxs(short trackCandidateType, Params_pT5::ArrayUxHits const& tcHitIndices, @@ -57,195 +47,21 @@ namespace { } // namespace -void LST::prepareInput(std::vector const& see_px, - std::vector const& see_py, - std::vector const& see_pz, - std::vector const& see_dxy, - std::vector const& see_dz, - std::vector const& see_ptErr, - std::vector const& see_etaErr, - std::vector const& see_stateTrajGlbX, - std::vector const& see_stateTrajGlbY, - std::vector const& see_stateTrajGlbZ, - std::vector const& see_stateTrajGlbPx, - std::vector const& see_stateTrajGlbPy, - std::vector const& see_stateTrajGlbPz, - std::vector const& see_q, - std::vector> const& see_hitIdx, - std::vector const& ph2_detId, - std::vector const& ph2_x, - std::vector const& ph2_y, - std::vector const& ph2_z, - float const ptCut) { - in_trkX_.clear(); - in_trkY_.clear(); - in_trkZ_.clear(); - in_hitId_.clear(); - in_hitIdxs_.clear(); - in_hitIndices_vec0_.clear(); - in_hitIndices_vec1_.clear(); - in_hitIndices_vec2_.clear(); - in_hitIndices_vec3_.clear(); - in_deltaPhi_vec_.clear(); - in_ptIn_vec_.clear(); - in_ptErr_vec_.clear(); - in_px_vec_.clear(); - in_py_vec_.clear(); - in_pz_vec_.clear(); - in_eta_vec_.clear(); - in_etaErr_vec_.clear(); - in_phi_vec_.clear(); - in_charge_vec_.clear(); - in_seedIdx_vec_.clear(); - in_superbin_vec_.clear(); - in_pixelType_vec_.clear(); - in_isQuad_vec_.clear(); - - unsigned int count = 0; - auto n_see = see_stateTrajGlbPx.size(); - in_px_vec_.reserve(n_see); - in_py_vec_.reserve(n_see); - in_pz_vec_.reserve(n_see); - in_hitIndices_vec0_.reserve(n_see); - in_hitIndices_vec1_.reserve(n_see); - in_hitIndices_vec2_.reserve(n_see); - in_hitIndices_vec3_.reserve(n_see); - in_ptIn_vec_.reserve(n_see); - in_ptErr_vec_.reserve(n_see); - in_etaErr_vec_.reserve(n_see); - in_eta_vec_.reserve(n_see); - in_phi_vec_.reserve(n_see); - in_charge_vec_.reserve(n_see); - in_seedIdx_vec_.reserve(n_see); - in_deltaPhi_vec_.reserve(n_see); - in_trkX_ = ph2_x; - in_trkY_ = ph2_y; - in_trkZ_ = ph2_z; - in_hitId_ = ph2_detId; - in_hitIdxs_.resize(ph2_detId.size()); - - std::iota(in_hitIdxs_.begin(), in_hitIdxs_.end(), 0); - const int hit_size = in_trkX_.size(); - - for (size_t iSeed = 0; iSeed < n_see; iSeed++) { - XYZVector p3LH(see_stateTrajGlbPx[iSeed], see_stateTrajGlbPy[iSeed], see_stateTrajGlbPz[iSeed]); - float ptIn = p3LH.rho(); - float eta = p3LH.eta(); - float ptErr = see_ptErr[iSeed]; - - if ((ptIn > ptCut - 2 * ptErr)) { - XYZVector r3LH(see_stateTrajGlbX[iSeed], see_stateTrajGlbY[iSeed], see_stateTrajGlbZ[iSeed]); - XYZVector p3PCA(see_px[iSeed], see_py[iSeed], see_pz[iSeed]); - XYZVector r3PCA(calculateR3FromPCA(p3PCA, see_dxy[iSeed], see_dz[iSeed])); - - // The charge could be used directly in the line below - float pixelSegmentDeltaPhiChange = ROOT::Math::VectorUtil::DeltaPhi(p3LH, r3LH); - float etaErr = see_etaErr[iSeed]; - float px = p3LH.x(); - float py = p3LH.y(); - float pz = p3LH.z(); - - int charge = see_q[iSeed]; - PixelType pixtype = PixelType::kInvalid; - - if (ptIn >= 2.0) - pixtype = PixelType::kHighPt; - else if (ptIn >= (ptCut - 2 * ptErr) and ptIn < 2.0) { - if (pixelSegmentDeltaPhiChange >= 0) - pixtype = PixelType::kLowPtPosCurv; - else - pixtype = PixelType::kLowPtNegCurv; - } else - continue; - - unsigned int hitIdx0 = hit_size + count; - count++; - unsigned int hitIdx1 = hit_size + count; - count++; - unsigned int hitIdx2 = hit_size + count; - count++; - unsigned int hitIdx3; - if (see_hitIdx[iSeed].size() <= 3) - hitIdx3 = hitIdx2; - else { - hitIdx3 = hit_size + count; - count++; - } - - in_trkX_.push_back(r3PCA.x()); - in_trkY_.push_back(r3PCA.y()); - in_trkZ_.push_back(r3PCA.z()); - in_trkX_.push_back(p3PCA.rho()); - float p3PCA_Eta = p3PCA.eta(); - in_trkY_.push_back(p3PCA_Eta); - float p3PCA_Phi = p3PCA.phi(); - in_trkZ_.push_back(p3PCA_Phi); - in_trkX_.push_back(r3LH.x()); - in_trkY_.push_back(r3LH.y()); - in_trkZ_.push_back(r3LH.z()); - in_hitId_.push_back(1); - in_hitId_.push_back(1); - in_hitId_.push_back(1); - if (see_hitIdx[iSeed].size() > 3) { - in_trkX_.push_back(r3LH.x()); - in_trkY_.push_back(see_dxy[iSeed]); - in_trkZ_.push_back(see_dz[iSeed]); - in_hitId_.push_back(1); - } - in_px_vec_.push_back(px); - in_py_vec_.push_back(py); - in_pz_vec_.push_back(pz); - - in_hitIndices_vec0_.push_back(hitIdx0); - in_hitIndices_vec1_.push_back(hitIdx1); - in_hitIndices_vec2_.push_back(hitIdx2); - in_hitIndices_vec3_.push_back(hitIdx3); - in_ptIn_vec_.push_back(ptIn); - in_ptErr_vec_.push_back(ptErr); - in_etaErr_vec_.push_back(etaErr); - in_eta_vec_.push_back(eta); - float phi = p3LH.phi(); - in_phi_vec_.push_back(phi); - in_charge_vec_.push_back(charge); - in_seedIdx_vec_.push_back(iSeed); - in_deltaPhi_vec_.push_back(pixelSegmentDeltaPhiChange); - - in_hitIdxs_.push_back(see_hitIdx[iSeed][0]); - in_hitIdxs_.push_back(see_hitIdx[iSeed][1]); - in_hitIdxs_.push_back(see_hitIdx[iSeed][2]); - char isQuad = false; - if (see_hitIdx[iSeed].size() > 3) { - isQuad = true; - in_hitIdxs_.push_back(see_hitIdx[iSeed][3]); - } - float neta = 25.; - float nphi = 72.; - float nz = 25.; - int etabin = (p3PCA_Eta + 2.6) / ((2 * 2.6) / neta); - int phibin = (p3PCA_Phi + kPi) / ((2. * kPi) / nphi); - int dzbin = (see_dz[iSeed] + 30) / (2 * 30 / nz); - int isuperbin = (nz * nphi) * etabin + (nz)*phibin + dzbin; - in_superbin_vec_.push_back(isuperbin); - in_pixelType_vec_.push_back(pixtype); - in_isQuad_vec_.push_back(isQuad); - } - } -} - void LST::getOutput(LSTEvent& event) { out_tc_hitIdxs_.clear(); out_tc_len_.clear(); out_tc_seedIdx_.clear(); out_tc_trackCandidateType_.clear(); - auto const hits = event.getHits(/*inCMSSW*/ true, /*sync*/ false); // sync on next line + auto const hitsBase = event.getTrimmedHitsBase(false); // sync on next line auto const& trackCandidates = event.getTrackCandidates(/*inCMSSW*/ true, /*sync*/ true); unsigned int nTrackCandidates = trackCandidates.nTrackCandidates(); for (unsigned int idx = 0; idx < nTrackCandidates; idx++) { short trackCandidateType = trackCandidates.trackCandidateType()[idx]; - std::vector hit_idx = getHitIdxs(trackCandidateType, trackCandidates.hitIndices()[idx], hits.idxs()); + std::vector hit_idx = + getHitIdxs(trackCandidateType, trackCandidates.hitIndices()[idx], hitsBase.idxs()); out_tc_hitIdxs_.push_back(hit_idx); out_tc_len_.push_back(hit_idx.size()); @@ -258,63 +74,14 @@ void LST::run(Queue& queue, bool verbose, float const ptCut, LSTESData const* deviceESData, - std::vector const& see_px, - std::vector const& see_py, - std::vector const& see_pz, - std::vector const& see_dxy, - std::vector const& see_dz, - std::vector const& see_ptErr, - std::vector const& see_etaErr, - std::vector const& see_stateTrajGlbX, - std::vector const& see_stateTrajGlbY, - std::vector const& see_stateTrajGlbZ, - std::vector const& see_stateTrajGlbPx, - std::vector const& see_stateTrajGlbPy, - std::vector const& see_stateTrajGlbPz, - std::vector const& see_q, - std::vector> const& see_hitIdx, - std::vector const& ph2_detId, - std::vector const& ph2_x, - std::vector const& ph2_y, - std::vector const& ph2_z, + LSTInputDeviceCollection const* lstInputDC, bool no_pls_dupclean, bool tc_pls_triplets) { auto event = LSTEvent(verbose, ptCut, queue, deviceESData); - prepareInput(see_px, - see_py, - see_pz, - see_dxy, - see_dz, - see_ptErr, - see_etaErr, - see_stateTrajGlbX, - see_stateTrajGlbY, - see_stateTrajGlbZ, - see_stateTrajGlbPx, - see_stateTrajGlbPy, - see_stateTrajGlbPz, - see_q, - see_hitIdx, - ph2_detId, - ph2_x, - ph2_y, - ph2_z, - ptCut); - event.addHitToEvent(in_trkX_, in_trkY_, in_trkZ_, in_hitId_, in_hitIdxs_); - event.addPixelSegmentToEventStart(in_ptIn_vec_, - in_ptErr_vec_, - in_px_vec_, - in_py_vec_, - in_pz_vec_, - in_eta_vec_, - in_etaErr_vec_, - in_phi_vec_, - in_charge_vec_, - in_seedIdx_vec_, - in_superbin_vec_, - in_pixelType_vec_, - in_isQuad_vec_); + event.addInputToEvent(lstInputDC); + event.addHitToEvent(); + event.addPixelSegmentToEventStart(); event.createMiniDoublets(); if (verbose) { alpaka::wait(queue); // event calls are asynchronous: wait before printing @@ -383,8 +150,7 @@ void LST::run(Queue& queue, printf("# of Quintuplets produced endcap layer 5: %d\n", event.getNumberOfQuintupletsByLayerEndcap(4)); } - event.addPixelSegmentToEventFinalize( - in_hitIndices_vec0_, in_hitIndices_vec1_, in_hitIndices_vec2_, in_hitIndices_vec3_, in_deltaPhi_vec_); + event.addPixelSegmentToEventFinalize(); event.pixelLineSegmentCleaning(no_pls_dupclean); diff --git a/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc b/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc index 79b3e3707deb7..a6ead7d5ef4d2 100644 --- a/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc +++ b/RecoTracker/LSTCore/src/alpaka/LSTEvent.dev.cc @@ -1,5 +1,6 @@ #include "HeterogeneousCore/AlpakaInterface/interface/memory.h" #include "HeterogeneousCore/AlpakaInterface/interface/workdivision.h" +#include "HeterogeneousCore/AlpakaInterface/interface/CopyToDevice.h" #include "LSTEvent.h" @@ -53,9 +54,10 @@ void LSTEvent::resetEventSync() { n_quintuplets_by_layer_endcap_[i] = 0; } } + lstInputDC_ = nullptr; hitsDC_.reset(); - miniDoubletsDC_.reset(); rangesDC_.reset(); + miniDoubletsDC_.reset(); segmentsDC_.reset(); pixelSegmentsDC_.reset(); tripletsDC_.reset(); @@ -64,6 +66,7 @@ void LSTEvent::resetEventSync() { pixelTripletsDC_.reset(); pixelQuintupletsDC_.reset(); + lstInputHC_.reset(); hitsHC_.reset(); rangesHC_.reset(); miniDoubletsHC_.reset(); @@ -77,35 +80,20 @@ void LSTEvent::resetEventSync() { modulesHC_.reset(); } -void LSTEvent::addHitToEvent(std::vector const& x, - std::vector const& y, - std::vector const& z, - std::vector const& detId, - std::vector const& idxInNtuple) { - // Use the actual number of hits instead of a max. - unsigned int nHits = x.size(); +void LSTEvent::addInputToEvent(LSTInputDeviceCollection const* lstInputDC) { + lstInputDC_ = lstInputDC; + + pixelSize_ = lstInputDC_->sizes()[1]; + pixelModuleIndex_ = pixelMapping_.pixelModuleIndex; +} - // Initialize space on device/host for next event. +void LSTEvent::addHitToEvent() { if (!hitsDC_) { - std::array const hits_sizes{{static_cast(nHits), static_cast(nModules_)}}; + int nHits = lstInputDC_->sizes()[0]; + std::array const hits_sizes{{nHits, static_cast(nModules_)}}; hitsDC_.emplace(hits_sizes, queue_); - - auto hitsRanges = hitsDC_->view(); - auto hitRanges_view = - cms::alpakatools::make_device_view(queue_, hitsRanges.hitRanges(), hitsRanges.metadata().size()); - auto hitRangesLower_view = - cms::alpakatools::make_device_view(queue_, hitsRanges.hitRangesLower(), hitsRanges.metadata().size()); - auto hitRangesUpper_view = - cms::alpakatools::make_device_view(queue_, hitsRanges.hitRangesUpper(), hitsRanges.metadata().size()); - auto hitRangesnLower_view = - cms::alpakatools::make_device_view(queue_, hitsRanges.hitRangesnLower(), hitsRanges.metadata().size()); - auto hitRangesnUpper_view = - cms::alpakatools::make_device_view(queue_, hitsRanges.hitRangesnUpper(), hitsRanges.metadata().size()); - alpaka::memset(queue_, hitRanges_view, 0xff); - alpaka::memset(queue_, hitRangesLower_view, 0xff); - alpaka::memset(queue_, hitRangesUpper_view, 0xff); - alpaka::memset(queue_, hitRangesnLower_view, 0xff); - alpaka::memset(queue_, hitRangesnUpper_view, 0xff); + auto buf = hitsDC_->buffer(); + alpaka::memset(queue_, buf, 0xff); } if (!rangesDC_) { @@ -114,20 +102,6 @@ void LSTEvent::addHitToEvent(std::vector const& x, alpaka::memset(queue_, buf, 0xff); } - // Copy the host arrays to the GPU. - auto hits = hitsDC_->view(); - auto xs_d = cms::alpakatools::make_device_view(queue_, hits.xs(), (Idx)hits.metadata().size()); - auto ys_d = cms::alpakatools::make_device_view(queue_, hits.ys(), (Idx)hits.metadata().size()); - auto zs_d = cms::alpakatools::make_device_view(queue_, hits.zs(), (Idx)hits.metadata().size()); - auto detId_d = cms::alpakatools::make_device_view(queue_, hits.detid(), (Idx)hits.metadata().size()); - auto idxs_d = cms::alpakatools::make_device_view(queue_, hits.idxs(), (Idx)hits.metadata().size()); - alpaka::memcpy(queue_, xs_d, x, (Idx)nHits); - alpaka::memcpy(queue_, ys_d, y, (Idx)nHits); - alpaka::memcpy(queue_, zs_d, z, (Idx)nHits); - alpaka::memcpy(queue_, detId_d, detId, (Idx)nHits); - alpaka::memcpy(queue_, idxs_d, idxInNtuple, (Idx)nHits); - alpaka::wait(queue_); // FIXME: remove synch after inputs refactored to be in pinned memory - auto const hit_loop_workdiv = cms::alpakatools::make_workdiv(max_blocks, 256); alpaka::exec(queue_, @@ -139,9 +113,9 @@ void LSTEvent::addHitToEvent(std::vector const& x, nEndCapMap_, endcapGeometry_.const_view(), modules_.const_view(), - hitsDC_->view(), - hitsDC_->view(), - nHits); + lstInputDC_->const_view(), + hitsDC_->view(), + hitsDC_->view()); auto const module_ranges_workdiv = cms::alpakatools::make_workdiv(max_blocks, 256); @@ -153,69 +127,22 @@ void LSTEvent::addHitToEvent(std::vector const& x, nLowerModules_); } -void LSTEvent::addPixelSegmentToEventStart(std::vector const& ptIn, - std::vector const& ptErr, - std::vector const& px, - std::vector const& py, - std::vector const& pz, - std::vector const& eta, - std::vector const& etaErr, - std::vector const& phi, - std::vector const& charge, - std::vector const& seedIdx, - std::vector const& superbin, - std::vector const& pixelType, - std::vector const& isQuad) { - unsigned int size = ptIn.size(); - pixelSize_ = size; - - if (size > n_max_pixel_segments_per_module) { +void LSTEvent::addPixelSegmentToEventStart() { + if (pixelSize_ == n_max_pixel_segments_per_module) { lstWarning( "\ - *********************************************************\n\ - * Warning: Pixel line segments will be truncated. *\n\ - * You need to increase n_max_pixel_segments_per_module. *\n\ - *********************************************************"); - size = n_max_pixel_segments_per_module; + *********************************************************\n\ + * Warning: Pixel line segments may be truncated. *\n\ + * You need to increase n_max_pixel_segments_per_module. *\n\ + *********************************************************"); } - pixelModuleIndex_ = pixelMapping_.pixelModuleIndex; - - pixelSegmentsDC_.emplace(n_max_pixel_segments_per_module, queue_); - - PixelSegments pixelSegments = pixelSegmentsDC_->view(); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.ptIn(), size), ptIn, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.ptErr(), size), ptErr, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.px(), size), px, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.py(), size), py, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.pz(), size), pz, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.etaErr(), size), etaErr, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.isQuad(), size), isQuad, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.eta(), size), eta, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.phi(), size), phi, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.charge(), size), charge, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.seedIdx(), size), seedIdx, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), size), superbin, size); - alpaka::memcpy(queue_, cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), size), pixelType, size); + if (!pixelSegmentsDC_) { + pixelSegmentsDC_.emplace(pixelSize_, queue_); + } } -void LSTEvent::addPixelSegmentToEventFinalize(std::vector hitIndices0, - std::vector hitIndices1, - std::vector hitIndices2, - std::vector hitIndices3, - std::vector deltaPhi_vec) { - auto hitIndices0_dev = cms::alpakatools::make_device_buffer(queue_, pixelSize_); - auto hitIndices1_dev = cms::alpakatools::make_device_buffer(queue_, pixelSize_); - auto hitIndices2_dev = cms::alpakatools::make_device_buffer(queue_, pixelSize_); - auto hitIndices3_dev = cms::alpakatools::make_device_buffer(queue_, pixelSize_); - auto dPhiChange_dev = cms::alpakatools::make_device_buffer(queue_, pixelSize_); - - alpaka::memcpy(queue_, hitIndices0_dev, hitIndices0, pixelSize_); - alpaka::memcpy(queue_, hitIndices1_dev, hitIndices1, pixelSize_); - alpaka::memcpy(queue_, hitIndices2_dev, hitIndices2, pixelSize_); - alpaka::memcpy(queue_, hitIndices3_dev, hitIndices3, pixelSize_); - alpaka::memcpy(queue_, dPhiChange_dev, deltaPhi_vec, pixelSize_); - +void LSTEvent::addPixelSegmentToEventFinalize() { auto const addPixelSegmentToEvent_workdiv = cms::alpakatools::make_workdiv(max_blocks, 256); alpaka::exec(queue_, @@ -223,15 +150,12 @@ void LSTEvent::addPixelSegmentToEventFinalize(std::vector hitIndic AddPixelSegmentToEventKernel{}, modules_.const_view(), rangesDC_->const_view(), - hitsDC_->view(), + lstInputDC_->const_view(), + hitsDC_->view(), + lstInputDC_->const_view(), miniDoubletsDC_->view(), segmentsDC_->view(), pixelSegmentsDC_->view(), - hitIndices0_dev.data(), - hitIndices1_dev.data(), - hitIndices2_dev.data(), - hitIndices3_dev.data(), - dPhiChange_dev.data(), pixelModuleIndex_, pixelSize_); } @@ -304,7 +228,8 @@ void LSTEvent::createMiniDoublets() { createMiniDoublets_workDiv, CreateMiniDoublets{}, modules_.const_view(), - hitsDC_->const_view(), + lstInputDC_->const_view(), + hitsDC_->const_view(), hitsDC_->const_view(), miniDoubletsDC_->view(), miniDoubletsDC_->view(), @@ -522,7 +447,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) modules_.const_view(), rangesDC_->const_view(), pixelTripletsDC_->view(), - pixelSegmentsDC_->const_view(), + lstInputDC_->const_view(), pixelQuintupletsDC_->const_view()); auto const addpT3asTrackCandidates_workDiv = cms::alpakatools::make_workdiv(1, 512); @@ -533,7 +458,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) nLowerModules_, pixelTripletsDC_->const_view(), trackCandidatesDC_->view(), - pixelSegmentsDC_->const_view(), + lstInputDC_->const_view(), rangesDC_->const_view()); // Pull nEligibleT5Modules from the device. @@ -589,6 +514,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) CheckHitspLS{}, modules_.const_view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->view(), true); } @@ -604,9 +530,10 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) trackCandidatesDC_->view(), segmentsDC_->const_view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->view(), miniDoubletsDC_->const_view(), - hitsDC_->const_view(), + lstInputDC_->const_view(), quintupletsDC_->const_view()); auto const addpLSasTrackCandidate_workDiv = cms::alpakatools::make_workdiv(max_blocks, 384); @@ -617,6 +544,7 @@ void LSTEvent::createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets) nLowerModules_, trackCandidatesDC_->view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->const_view(), tc_pls_triplets); @@ -665,18 +593,14 @@ void LSTEvent::createPixelTriplets() { alpaka::memset(queue_, totOccupancyPixelTriplets_view, 0u); } SegmentsOccupancy segmentsOccupancy = segmentsDC_->view(); - PixelSegmentsConst pixelSegments = pixelSegmentsDC_->view(); + PixelSeedsConst pixelSeeds = lstInputDC_->const_view(); auto superbins_buf = cms::alpakatools::make_host_buffer(queue_, n_max_pixel_segments_per_module); auto pixelTypes_buf = cms::alpakatools::make_host_buffer(queue_, n_max_pixel_segments_per_module); - alpaka::memcpy(queue_, - superbins_buf, - cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), n_max_pixel_segments_per_module)); + alpaka::memcpy(queue_, superbins_buf, cms::alpakatools::make_device_view(queue_, pixelSeeds.superbin(), pixelSize_)); alpaka::memcpy( - queue_, - pixelTypes_buf, - cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), n_max_pixel_segments_per_module)); + queue_, pixelTypes_buf, cms::alpakatools::make_device_view(queue_, pixelSeeds.pixelType(), pixelSize_)); auto const* superbins = superbins_buf.data(); auto const* pixelTypes = pixelTypes_buf.data(); @@ -754,6 +678,7 @@ void LSTEvent::createPixelTriplets() { rangesDC_->const_view(), miniDoubletsDC_->const_view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->const_view(), tripletsDC_->view(), tripletsDC_->const_view(), @@ -877,6 +802,7 @@ void LSTEvent::pixelLineSegmentCleaning(bool no_pls_dupclean) { CheckHitspLS{}, modules_.const_view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->view(), false); } @@ -898,18 +824,14 @@ void LSTEvent::createPixelQuintuplets() { alpaka::memset(queue_, buf, 0u); } SegmentsOccupancy segmentsOccupancy = segmentsDC_->view(); - PixelSegmentsConst pixelSegments = pixelSegmentsDC_->view(); + PixelSeedsConst pixelSeeds = lstInputDC_->const_view(); auto superbins_buf = cms::alpakatools::make_host_buffer(queue_, n_max_pixel_segments_per_module); auto pixelTypes_buf = cms::alpakatools::make_host_buffer(queue_, n_max_pixel_segments_per_module); - alpaka::memcpy(queue_, - superbins_buf, - cms::alpakatools::make_device_view(queue_, pixelSegments.superbin(), n_max_pixel_segments_per_module)); + alpaka::memcpy(queue_, superbins_buf, cms::alpakatools::make_device_view(queue_, pixelSeeds.superbin(), pixelSize_)); alpaka::memcpy( - queue_, - pixelTypes_buf, - cms::alpakatools::make_device_view(queue_, pixelSegments.pixelType(), n_max_pixel_segments_per_module)); + queue_, pixelTypes_buf, cms::alpakatools::make_device_view(queue_, pixelSeeds.pixelType(), pixelSize_)); auto const* superbins = superbins_buf.data(); auto const* pixelTypes = pixelTypes_buf.data(); @@ -987,6 +909,7 @@ void LSTEvent::createPixelQuintuplets() { modules_.const_view(), miniDoubletsDC_->const_view(), segmentsDC_->const_view(), + lstInputDC_->const_view(), pixelSegmentsDC_->view(), tripletsDC_->view(), quintupletsDC_->view(), @@ -1014,7 +937,7 @@ void LSTEvent::createPixelQuintuplets() { nLowerModules_, pixelQuintupletsDC_->const_view(), trackCandidatesDC_->view(), - pixelSegmentsDC_->const_view(), + lstInputDC_->const_view(), rangesDC_->const_view()); #ifdef WARNINGS @@ -1354,32 +1277,63 @@ int LSTEvent::getNumberOfT5TrackCandidates() { } template -typename TSoA::ConstView LSTEvent::getHits(bool inCMSSW, bool sync) { +typename TSoA::ConstView LSTEvent::getInput(bool sync) { + if constexpr (std::is_same_v) { + return lstInputDC_->const_view(); + } else { + // In case getTrimmedInput was called first + if (!lstInputHC_ || lstInputHC_->sizes()[1] == 0) { + lstInputHC_.emplace( + cms::alpakatools::CopyToHost>::copyAsync( + queue_, *lstInputDC_)); + if (sync) + alpaka::wait(queue_); // host consumers expect filled data + } + return lstInputHC_->const_view(); + } +} +template HitsBaseConst LSTEvent::getInput(bool); +template PixelSeedsConst LSTEvent::getInput(bool); + +template +HitsBaseConst LSTEvent::getTrimmedHitsBase(bool sync) { + if constexpr (std::is_same_v) { + return lstInputDC_->const_view(); + } else { + if (!lstInputHC_) { + auto hits_d = lstInputDC_->view(); + int nHits = hits_d.metadata().size(); + std::array const hits_sizes{{nHits, 0}}; + lstInputHC_.emplace(hits_sizes, queue_); + auto hits_h = lstInputHC_->view(); + auto idxs_h = cms::alpakatools::make_host_view(hits_h.idxs(), nHits); + auto idxs_d = cms::alpakatools::make_device_view(queue_, hits_d.idxs(), nHits); + alpaka::memcpy(queue_, idxs_h, idxs_d); + if (sync) + alpaka::wait(queue_); // host consumers expect filled data + } + return lstInputHC_->const_view(); + } +} +template HitsBaseConst LSTEvent::getTrimmedHitsBase(bool); + +template +typename TSoA::ConstView LSTEvent::getHits(bool sync) { if constexpr (std::is_same_v) { return hitsDC_->const_view(); } else { if (!hitsHC_) { - if (inCMSSW) { - auto hits_d = hitsDC_->view(); - auto nHits = hits_d.metadata().size(); - std::array const hits_sizes{{static_cast(nHits), static_cast(nModules_)}}; - hitsHC_.emplace(hits_sizes, queue_); - auto hits_h = hitsHC_->view(); - auto idxs_h = cms::alpakatools::make_host_view(hits_h.idxs(), nHits); - auto idxs_d = cms::alpakatools::make_device_view(queue_, hits_d.idxs(), nHits); - alpaka::memcpy(queue_, idxs_h, idxs_d); - } else { - hitsHC_.emplace(cms::alpakatools::CopyToHost>::copyAsync( - queue_, *hitsDC_)); - } + hitsHC_.emplace( + cms::alpakatools::CopyToHost>::copyAsync( + queue_, *hitsDC_)); if (sync) alpaka::wait(queue_); // host consumers expect filled data } return hitsHC_->const_view(); } } -template HitsConst LSTEvent::getHits(bool, bool); -template HitsRangesConst LSTEvent::getHits(bool, bool); +template HitsExtendedConst LSTEvent::getHits(bool); +template HitsRangesConst LSTEvent::getHits(bool); template ObjectRangesConst LSTEvent::getRanges(bool sync) { diff --git a/RecoTracker/LSTCore/src/alpaka/LSTEvent.h b/RecoTracker/LSTCore/src/alpaka/LSTEvent.h index 11ec7a9d53fa3..7c736f325aee4 100644 --- a/RecoTracker/LSTCore/src/alpaka/LSTEvent.h +++ b/RecoTracker/LSTCore/src/alpaka/LSTEvent.h @@ -3,6 +3,7 @@ #include +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" #include "RecoTracker/LSTCore/interface/HitsHostCollection.h" #include "RecoTracker/LSTCore/interface/MiniDoubletsHostCollection.h" #include "RecoTracker/LSTCore/interface/PixelQuintupletsHostCollection.h" @@ -16,6 +17,7 @@ #include "RecoTracker/LSTCore/interface/ModulesHostCollection.h" #include "RecoTracker/LSTCore/interface/alpaka/Common.h" #include "RecoTracker/LSTCore/interface/alpaka/LST.h" +#include "RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h" #include "RecoTracker/LSTCore/interface/alpaka/HitsDeviceCollection.h" #include "RecoTracker/LSTCore/interface/alpaka/MiniDoubletsDeviceCollection.h" #include "RecoTracker/LSTCore/interface/alpaka/PixelQuintupletsDeviceCollection.h" @@ -51,6 +53,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t pixelModuleIndex_; //Device stuff + LSTInputDeviceCollection const* lstInputDC_; // not owned std::optional rangesDC_; std::optional hitsDC_; std::optional miniDoubletsDC_; @@ -63,6 +66,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { std::optional pixelQuintupletsDC_; //CPU interface stuff + std::optional lstInputHC_; std::optional rangesHC_; std::optional hitsHC_; std::optional miniDoubletsHC_; @@ -106,32 +110,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { void resetEventSync(); // synchronizes, for standalone usage void wait() const { alpaka::wait(queue_); } + void addInputToEvent(LSTInputDeviceCollection const* lstInputDC); // Calls the appropriate hit function, then increments the counter - void addHitToEvent(std::vector const& x, - std::vector const& y, - std::vector const& z, - std::vector const& detId, - std::vector const& idxInNtuple); - void addPixelSegmentToEventStart(std::vector const& ptIn, - std::vector const& ptErr, - std::vector const& px, - std::vector const& py, - std::vector const& pz, - std::vector const& eta, - std::vector const& etaErr, - std::vector const& phi, - std::vector const& charge, - std::vector const& seedIdx, - std::vector const& superbin, - std::vector const& pixelType, - std::vector const& isQuad); + void addHitToEvent(); + void addPixelSegmentToEventStart(); void createMiniDoublets(); - void addPixelSegmentToEventFinalize(std::vector hitIndices0, - std::vector hitIndices1, - std::vector hitIndices2, - std::vector hitIndices3, - std::vector deltaPhi_vec); + void addPixelSegmentToEventFinalize(); void createSegmentsWithModuleMap(); void createTriplets(); void createTrackCandidates(bool no_pls_dupclean, bool tc_pls_triplets); @@ -178,7 +163,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { // set to false may allow faster operation with concurrent calls of get* // HANDLE WITH CARE template - typename TSoA::ConstView getHits(bool inCMSSW = false, bool sync = true); + typename TSoA::ConstView getInput(bool sync = true); + template + HitsBaseConst getTrimmedHitsBase(bool sync = true); + template + typename TSoA::ConstView getHits(bool sync = true); template ObjectRangesConst getRanges(bool sync = true); template diff --git a/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h b/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h index 4e30e14b1c435..c4d9b213565e8 100644 --- a/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h +++ b/RecoTracker/LSTCore/src/alpaka/MiniDoublet.h @@ -16,7 +16,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { template ALPAKA_FN_ACC ALPAKA_FN_INLINE void addMDToMemory(TAcc const& acc, MiniDoublets mds, - HitsConst hits, + HitsBaseConst hitsBase, + HitsExtendedConst hitsExtended, ModulesConst modules, unsigned int lowerHitIdx, unsigned int upperHitIdx, @@ -60,29 +61,29 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { mds.noShiftedDphis()[idx] = noShiftedDphi; mds.noShiftedDphiChanges()[idx] = noShiftedDPhiChange; - mds.anchorX()[idx] = hits.xs()[anchorHitIndex]; - mds.anchorY()[idx] = hits.ys()[anchorHitIndex]; - mds.anchorZ()[idx] = hits.zs()[anchorHitIndex]; - mds.anchorRt()[idx] = hits.rts()[anchorHitIndex]; - mds.anchorPhi()[idx] = hits.phis()[anchorHitIndex]; - mds.anchorEta()[idx] = hits.etas()[anchorHitIndex]; - mds.anchorHighEdgeX()[idx] = hits.highEdgeXs()[anchorHitIndex]; - mds.anchorHighEdgeY()[idx] = hits.highEdgeYs()[anchorHitIndex]; - mds.anchorLowEdgeX()[idx] = hits.lowEdgeXs()[anchorHitIndex]; - mds.anchorLowEdgeY()[idx] = hits.lowEdgeYs()[anchorHitIndex]; + mds.anchorX()[idx] = hitsBase.xs()[anchorHitIndex]; + mds.anchorY()[idx] = hitsBase.ys()[anchorHitIndex]; + mds.anchorZ()[idx] = hitsBase.zs()[anchorHitIndex]; + mds.anchorRt()[idx] = hitsExtended.rts()[anchorHitIndex]; + mds.anchorPhi()[idx] = hitsExtended.phis()[anchorHitIndex]; + mds.anchorEta()[idx] = hitsExtended.etas()[anchorHitIndex]; + mds.anchorHighEdgeX()[idx] = hitsExtended.highEdgeXs()[anchorHitIndex]; + mds.anchorHighEdgeY()[idx] = hitsExtended.highEdgeYs()[anchorHitIndex]; + mds.anchorLowEdgeX()[idx] = hitsExtended.lowEdgeXs()[anchorHitIndex]; + mds.anchorLowEdgeY()[idx] = hitsExtended.lowEdgeYs()[anchorHitIndex]; mds.anchorHighEdgePhi()[idx] = alpaka::math::atan2(acc, mds.anchorHighEdgeY()[idx], mds.anchorHighEdgeX()[idx]); mds.anchorLowEdgePhi()[idx] = alpaka::math::atan2(acc, mds.anchorLowEdgeY()[idx], mds.anchorLowEdgeX()[idx]); - mds.outerX()[idx] = hits.xs()[outerHitIndex]; - mds.outerY()[idx] = hits.ys()[outerHitIndex]; - mds.outerZ()[idx] = hits.zs()[outerHitIndex]; - mds.outerRt()[idx] = hits.rts()[outerHitIndex]; - mds.outerPhi()[idx] = hits.phis()[outerHitIndex]; - mds.outerEta()[idx] = hits.etas()[outerHitIndex]; - mds.outerHighEdgeX()[idx] = hits.highEdgeXs()[outerHitIndex]; - mds.outerHighEdgeY()[idx] = hits.highEdgeYs()[outerHitIndex]; - mds.outerLowEdgeX()[idx] = hits.lowEdgeXs()[outerHitIndex]; - mds.outerLowEdgeY()[idx] = hits.lowEdgeYs()[outerHitIndex]; + mds.outerX()[idx] = hitsBase.xs()[outerHitIndex]; + mds.outerY()[idx] = hitsBase.ys()[outerHitIndex]; + mds.outerZ()[idx] = hitsBase.zs()[outerHitIndex]; + mds.outerRt()[idx] = hitsExtended.rts()[outerHitIndex]; + mds.outerPhi()[idx] = hitsExtended.phis()[outerHitIndex]; + mds.outerEta()[idx] = hitsExtended.etas()[outerHitIndex]; + mds.outerHighEdgeX()[idx] = hitsExtended.highEdgeXs()[outerHitIndex]; + mds.outerHighEdgeY()[idx] = hitsExtended.highEdgeYs()[outerHitIndex]; + mds.outerLowEdgeX()[idx] = hitsExtended.lowEdgeXs()[outerHitIndex]; + mds.outerLowEdgeY()[idx] = hitsExtended.lowEdgeYs()[outerHitIndex]; } ALPAKA_FN_ACC ALPAKA_FN_INLINE bool isTighterTiltedModules(ModulesConst modules, uint16_t moduleIndex) { @@ -676,7 +677,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { struct CreateMiniDoublets { ALPAKA_FN_ACC void operator()(Acc2D const& acc, ModulesConst modules, - HitsConst hits, + HitsBaseConst hitsBase, + HitsExtendedConst hitsExtended, HitsRangesConst hitsRanges, MiniDoublets mds, MiniDoubletsOccupancy mdsOccupancy, @@ -700,15 +702,15 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { if (lowerHitIndex >= nLowerHits) continue; unsigned int lowerHitArrayIndex = loHitArrayIndex + lowerHitIndex; - float xLower = hits.xs()[lowerHitArrayIndex]; - float yLower = hits.ys()[lowerHitArrayIndex]; - float zLower = hits.zs()[lowerHitArrayIndex]; - float rtLower = hits.rts()[lowerHitArrayIndex]; + float xLower = hitsBase.xs()[lowerHitArrayIndex]; + float yLower = hitsBase.ys()[lowerHitArrayIndex]; + float zLower = hitsBase.zs()[lowerHitArrayIndex]; + float rtLower = hitsExtended.rts()[lowerHitArrayIndex]; unsigned int upperHitArrayIndex = upHitArrayIndex + upperHitIndex; - float xUpper = hits.xs()[upperHitArrayIndex]; - float yUpper = hits.ys()[upperHitArrayIndex]; - float zUpper = hits.zs()[upperHitArrayIndex]; - float rtUpper = hits.rts()[upperHitArrayIndex]; + float xUpper = hitsBase.xs()[upperHitArrayIndex]; + float yUpper = hitsBase.ys()[upperHitArrayIndex]; + float zUpper = hitsBase.zs()[upperHitArrayIndex]; + float rtUpper = hitsExtended.rts()[upperHitArrayIndex]; float dz, dphi, dphichange, shiftedX, shiftedY, shiftedZ, noShiftedDphi, noShiftedDphiChange; bool success = runMiniDoubletDefaultAlgo(acc, @@ -749,7 +751,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { addMDToMemory(acc, mds, - hits, + hitsBase, + hitsExtended, modules, lowerHitArrayIndex, upperHitArrayIndex, diff --git a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h index c6c88b31a5fce..746f6adadc0f8 100644 --- a/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h +++ b/RecoTracker/LSTCore/src/alpaka/PixelQuintuplet.h @@ -470,6 +470,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, + PixelSeedsConst pixelSeeds, PixelSegmentsConst pixelSegments, TripletsConst triplets, QuintupletsConst quintuplets, @@ -495,6 +496,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, + pixelSeeds, pixelSegments, triplets, pixelSegmentIndex, @@ -547,11 +549,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { mds.anchorRt()[fourthMDIndex], mds.anchorRt()[fifthMDIndex]}; - float pixelSegmentPt = pixelSegments.ptIn()[pixelSegmentArrayIndex]; - float pixelSegmentPx = pixelSegments.px()[pixelSegmentArrayIndex]; - float pixelSegmentPy = pixelSegments.py()[pixelSegmentArrayIndex]; - float pixelSegmentPz = pixelSegments.pz()[pixelSegmentArrayIndex]; - int pixelSegmentCharge = pixelSegments.charge()[pixelSegmentArrayIndex]; + float pixelSegmentPt = pixelSeeds.ptIn()[pixelSegmentArrayIndex]; + float pixelSegmentPx = pixelSeeds.px()[pixelSegmentArrayIndex]; + float pixelSegmentPy = pixelSeeds.py()[pixelSegmentArrayIndex]; + float pixelSegmentPz = pixelSeeds.pz()[pixelSegmentArrayIndex]; + int pixelSegmentCharge = pixelSeeds.charge()[pixelSegmentArrayIndex]; rzChiSquared = 0; @@ -641,6 +643,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ModulesPixelConst modulesPixel, MiniDoubletsConst mds, SegmentsConst segments, + PixelSeedsConst pixelSeeds, PixelSegments pixelSegments, Triplets triplets, Quintuplets quintuplets, @@ -686,6 +689,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, + pixelSeeds, pixelSegments, triplets, quintuplets, diff --git a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h index 571bfd4270547..ab2fb25e44243 100644 --- a/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h +++ b/RecoTracker/LSTCore/src/alpaka/PixelTriplet.h @@ -21,7 +21,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -38,7 +38,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -121,7 +121,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, uint16_t pixelLowerModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -144,7 +144,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, - pixelSegments, + pixelSeeds, pixelLowerModuleIndex, outerInnerLowerModuleIndex, outerOuterLowerModuleIndex, @@ -161,7 +161,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, - pixelSegments, + pixelSeeds, pixelLowerModuleIndex, outerInnerLowerModuleIndex, outerOuterLowerModuleIndex, @@ -200,7 +200,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { } /* else if(layer1 == 7 and layer2 == 8 and layer3 == 14) - { + { // PS+PS+2S in endcap layers 1+2+3, which is not really feasible in the current geometry, // without skipping barrel layers 1 and 2 (not allowed by algorithm logic). } @@ -634,6 +634,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, + PixelSeedsConst pixelSeeds, PixelSegmentsConst pixelSegments, TripletsConst triplets, unsigned int pixelSegmentIndex, @@ -661,7 +662,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, - pixelSegments, + pixelSeeds, pixelModuleIndex, lowerModuleIndex, middleModuleIndex, @@ -676,7 +677,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, - pixelSegments, + pixelSeeds, pixelModuleIndex, middleModuleIndex, upperModuleIndex, @@ -688,12 +689,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { //pt matching between the pixel ptin and the triplet circle pt unsigned int pixelSegmentArrayIndex = pixelSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex]; - float pixelSegmentPt = pixelSegments.ptIn()[pixelSegmentArrayIndex]; - float pixelSegmentPtError = pixelSegments.ptErr()[pixelSegmentArrayIndex]; - float pixelSegmentPx = pixelSegments.px()[pixelSegmentArrayIndex]; - float pixelSegmentPy = pixelSegments.py()[pixelSegmentArrayIndex]; - float pixelSegmentPz = pixelSegments.pz()[pixelSegmentArrayIndex]; - int pixelSegmentCharge = pixelSegments.charge()[pixelSegmentArrayIndex]; + float pixelSegmentPt = pixelSeeds.ptIn()[pixelSegmentArrayIndex]; + float pixelSegmentPtError = pixelSeeds.ptErr()[pixelSegmentArrayIndex]; + float pixelSegmentPx = pixelSeeds.px()[pixelSegmentArrayIndex]; + float pixelSegmentPy = pixelSeeds.py()[pixelSegmentArrayIndex]; + float pixelSegmentPz = pixelSeeds.pz()[pixelSegmentArrayIndex]; + int pixelSegmentCharge = pixelSeeds.charge()[pixelSegmentArrayIndex]; float pixelG = pixelSegments.circleCenterX()[pixelSegmentArrayIndex]; float pixelF = pixelSegments.circleCenterY()[pixelSegmentArrayIndex]; @@ -793,6 +794,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, + PixelSeedsConst pixelSeeds, PixelSegmentsConst pixelSegments, Triplets triplets, TripletsOccupancyConst tripletsOccupancy, @@ -860,6 +862,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ranges, mds, segments, + pixelSeeds, pixelSegments, triplets, pixelSegmentIndex, @@ -880,9 +883,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { float eta = mds.anchorEta()[segments .mdIndices()[triplets.segmentIndices()[outerTripletIndex][0]][layer2_adjustment]]; - float eta_pix = pixelSegments.eta()[i_pLS]; - float phi_pix = pixelSegments.phi()[i_pLS]; - float pt = pixelSegments.ptIn()[i_pLS]; + float eta_pix = pixelSeeds.eta()[i_pLS]; + float phi_pix = pixelSeeds.phi()[i_pLS]; + float pt = pixelSeeds.ptIn()[i_pLS]; float score = rPhiChiSquared + rPhiChiSquaredInwards; unsigned int totOccupancyPixelTriplets = alpaka::atomicAdd(acc, &pixelTriplets.totOccupancyPixelTriplets(), 1u, alpaka::hierarchy::Threads{}); @@ -928,7 +931,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -967,13 +970,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { return false; unsigned int pixelSegmentArrayIndex = innerSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex]; - float ptIn = pixelSegments.ptIn()[pixelSegmentArrayIndex]; + float ptIn = pixelSeeds.ptIn()[pixelSegmentArrayIndex]; float ptSLo = ptIn; - float px = pixelSegments.px()[pixelSegmentArrayIndex]; - float py = pixelSegments.py()[pixelSegmentArrayIndex]; - float pz = pixelSegments.pz()[pixelSegmentArrayIndex]; - float ptErr = pixelSegments.ptErr()[pixelSegmentArrayIndex]; - float etaErr = pixelSegments.etaErr()[pixelSegmentArrayIndex]; + float px = pixelSeeds.px()[pixelSegmentArrayIndex]; + float py = pixelSeeds.py()[pixelSegmentArrayIndex]; + float pz = pixelSeeds.pz()[pixelSegmentArrayIndex]; + float ptErr = pixelSeeds.ptErr()[pixelSegmentArrayIndex]; + float etaErr = pixelSeeds.etaErr()[pixelSegmentArrayIndex]; ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo)); ptSLo = alpaka::math::min(acc, 10.0f, ptSLo); @@ -1187,7 +1190,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ObjectRangesConst ranges, MiniDoubletsConst mds, SegmentsConst segments, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, uint16_t pixelModuleIndex, uint16_t outerInnerLowerModuleIndex, uint16_t outerOuterLowerModuleIndex, @@ -1225,13 +1228,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int pixelSegmentArrayIndex = innerSegmentIndex - ranges.segmentModuleIndices()[pixelModuleIndex]; - float ptIn = pixelSegments.ptIn()[pixelSegmentArrayIndex]; + float ptIn = pixelSeeds.ptIn()[pixelSegmentArrayIndex]; float ptSLo = ptIn; - float px = pixelSegments.px()[pixelSegmentArrayIndex]; - float py = pixelSegments.py()[pixelSegmentArrayIndex]; - float pz = pixelSegments.pz()[pixelSegmentArrayIndex]; - float ptErr = pixelSegments.ptErr()[pixelSegmentArrayIndex]; - float etaErr = pixelSegments.etaErr()[pixelSegmentArrayIndex]; + float px = pixelSeeds.px()[pixelSegmentArrayIndex]; + float py = pixelSeeds.py()[pixelSegmentArrayIndex]; + float pz = pixelSeeds.pz()[pixelSegmentArrayIndex]; + float ptErr = pixelSeeds.ptErr()[pixelSegmentArrayIndex]; + float etaErr = pixelSeeds.etaErr()[pixelSegmentArrayIndex]; ptSLo = alpaka::math::max(acc, ptCut, ptSLo - 10.0f * alpaka::math::max(acc, ptErr, 0.005f * ptSLo)); ptSLo = alpaka::math::min(acc, 10.0f, ptSLo); diff --git a/RecoTracker/LSTCore/src/alpaka/Segment.h b/RecoTracker/LSTCore/src/alpaka/Segment.h index 3e70bf4dbe569..3893f8799fe04 100644 --- a/RecoTracker/LSTCore/src/alpaka/Segment.h +++ b/RecoTracker/LSTCore/src/alpaka/Segment.h @@ -730,15 +730,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ALPAKA_FN_ACC void operator()(Acc1D const& acc, ModulesConst modules, ObjectRangesConst ranges, - HitsConst hits, + HitsBaseConst hitsBase, + HitsExtendedConst hitsExtended, + PixelSeedsConst pixelSeeds, MiniDoublets mds, Segments segments, PixelSegments pixelSegments, - unsigned int* hitIndices0, - unsigned int* hitIndices1, - unsigned int* hitIndices2, - unsigned int* hitIndices3, - float* dPhiChange, uint16_t pixelModuleIndex, int size) const { for (int tid : cms::alpakatools::uniform_elements(acc, size)) { @@ -748,10 +745,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { addMDToMemory(acc, mds, - hits, + hitsBase, + hitsExtended, modules, - hitIndices0[tid], - hitIndices1[tid], + pixelSeeds.hitIndices()[tid][0], + pixelSeeds.hitIndices()[tid][1], pixelModuleIndex, 0, 0, @@ -764,10 +762,11 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { innerMDIndex); addMDToMemory(acc, mds, - hits, + hitsBase, + hitsExtended, modules, - hitIndices2[tid], - hitIndices3[tid], + pixelSeeds.hitIndices()[tid][2], + pixelSeeds.hitIndices()[tid][3], pixelModuleIndex, 0, 0, @@ -780,18 +779,18 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { outerMDIndex); //in outer hits - pt, eta, phi - float slope = alpaka::math::sinh(acc, hits.ys()[mds.outerHitIndices()[innerMDIndex]]); - float intercept = - hits.zs()[mds.anchorHitIndices()[innerMDIndex]] - slope * hits.rts()[mds.anchorHitIndices()[innerMDIndex]]; - float score_lsq = (hits.rts()[mds.anchorHitIndices()[outerMDIndex]] * slope + intercept) - - (hits.zs()[mds.anchorHitIndices()[outerMDIndex]]); + float slope = alpaka::math::sinh(acc, hitsBase.ys()[mds.outerHitIndices()[innerMDIndex]]); + float intercept = hitsBase.zs()[mds.anchorHitIndices()[innerMDIndex]] - + slope * hitsExtended.rts()[mds.anchorHitIndices()[innerMDIndex]]; + float score_lsq = (hitsExtended.rts()[mds.anchorHitIndices()[outerMDIndex]] * slope + intercept) - + (hitsBase.zs()[mds.anchorHitIndices()[outerMDIndex]]); score_lsq = score_lsq * score_lsq; unsigned int hits1[Params_pLS::kHits]; - hits1[0] = hits.idxs()[mds.anchorHitIndices()[innerMDIndex]]; - hits1[1] = hits.idxs()[mds.anchorHitIndices()[outerMDIndex]]; - hits1[2] = hits.idxs()[mds.outerHitIndices()[innerMDIndex]]; - hits1[3] = hits.idxs()[mds.outerHitIndices()[outerMDIndex]]; + hits1[0] = hitsBase.idxs()[mds.anchorHitIndices()[innerMDIndex]]; + hits1[1] = hitsBase.idxs()[mds.anchorHitIndices()[outerMDIndex]]; + hits1[2] = hitsBase.idxs()[mds.outerHitIndices()[innerMDIndex]]; + hits1[3] = hitsBase.idxs()[mds.outerHitIndices()[outerMDIndex]]; addPixelSegmentToMemory(acc, segments, pixelSegments, @@ -800,9 +799,9 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { outerMDIndex, pixelModuleIndex, hits1, - hitIndices0[tid], - hitIndices2[tid], - dPhiChange[tid], + pixelSeeds.hitIndices()[tid][0], + pixelSeeds.hitIndices()[tid][2], + pixelSeeds.deltaPhi()[tid], pixelSegmentIndex, tid, score_lsq); diff --git a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h index 86124b413c3cb..da8e6eb8a8982 100644 --- a/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h +++ b/RecoTracker/LSTCore/src/alpaka/TrackCandidate.h @@ -71,19 +71,19 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { } ALPAKA_FN_ACC ALPAKA_FN_INLINE int checkPixelHits( - unsigned int ix, unsigned int jx, MiniDoubletsConst mds, SegmentsConst segments, HitsConst hits) { + unsigned int ix, unsigned int jx, MiniDoubletsConst mds, SegmentsConst segments, HitsBaseConst hitsBase) { int phits1[Params_pLS::kHits]; int phits2[Params_pLS::kHits]; - phits1[0] = hits.idxs()[mds.anchorHitIndices()[segments.mdIndices()[ix][0]]]; - phits1[1] = hits.idxs()[mds.anchorHitIndices()[segments.mdIndices()[ix][1]]]; - phits1[2] = hits.idxs()[mds.outerHitIndices()[segments.mdIndices()[ix][0]]]; - phits1[3] = hits.idxs()[mds.outerHitIndices()[segments.mdIndices()[ix][1]]]; + phits1[0] = hitsBase.idxs()[mds.anchorHitIndices()[segments.mdIndices()[ix][0]]]; + phits1[1] = hitsBase.idxs()[mds.anchorHitIndices()[segments.mdIndices()[ix][1]]]; + phits1[2] = hitsBase.idxs()[mds.outerHitIndices()[segments.mdIndices()[ix][0]]]; + phits1[3] = hitsBase.idxs()[mds.outerHitIndices()[segments.mdIndices()[ix][1]]]; - phits2[0] = hits.idxs()[mds.anchorHitIndices()[segments.mdIndices()[jx][0]]]; - phits2[1] = hits.idxs()[mds.anchorHitIndices()[segments.mdIndices()[jx][1]]]; - phits2[2] = hits.idxs()[mds.outerHitIndices()[segments.mdIndices()[jx][0]]]; - phits2[3] = hits.idxs()[mds.outerHitIndices()[segments.mdIndices()[jx][1]]]; + phits2[0] = hitsBase.idxs()[mds.anchorHitIndices()[segments.mdIndices()[jx][0]]]; + phits2[1] = hitsBase.idxs()[mds.anchorHitIndices()[segments.mdIndices()[jx][1]]]; + phits2[2] = hitsBase.idxs()[mds.outerHitIndices()[segments.mdIndices()[jx][0]]]; + phits2[3] = hitsBase.idxs()[mds.outerHitIndices()[segments.mdIndices()[jx][1]]]; int npMatched = 0; @@ -112,7 +112,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { ModulesConst modules, ObjectRangesConst ranges, PixelTriplets pixelTriplets, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, PixelQuintupletsConst pixelQuintuplets) const { unsigned int nPixelTriplets = pixelTriplets.nPixelTriplets(); for (unsigned int pixelTripletIndex : cms::alpakatools::uniform_elements_y(acc, nPixelTriplets)) { @@ -129,8 +129,8 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { unsigned int nPixelQuintuplets = pixelQuintuplets.nPixelQuintuplets(); for (unsigned int pixelQuintupletIndex : cms::alpakatools::uniform_elements_x(acc, nPixelQuintuplets)) { unsigned int pLS_jx = pixelQuintuplets.pixelSegmentIndices()[pixelQuintupletIndex]; - float eta2 = pixelSegments.eta()[pLS_jx - prefix]; - float phi2 = pixelSegments.phi()[pLS_jx - prefix]; + float eta2 = pixelSeeds.eta()[pLS_jx - prefix]; + float phi2 = pixelSeeds.phi()[pLS_jx - prefix]; float dEta = alpaka::math::abs(acc, (eta1 - eta2)); float dPhi = cms::alpakatools::deltaPhi(acc, phi1, phi2); @@ -198,18 +198,19 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { TrackCandidates cands, SegmentsConst segments, SegmentsOccupancyConst segmentsOccupancy, + PixelSeedsConst pixelSeeds, PixelSegments pixelSegments, MiniDoubletsConst mds, - HitsConst hits, + HitsBaseConst hitsBase, QuintupletsConst quintuplets) const { int pixelModuleIndex = modules.nLowerModules(); unsigned int nPixels = segmentsOccupancy.nSegments()[pixelModuleIndex]; for (unsigned int pixelArrayIndex : cms::alpakatools::uniform_elements_y(acc, nPixels)) { - if (!pixelSegments.isQuad()[pixelArrayIndex] || pixelSegments.isDup()[pixelArrayIndex]) + if (!pixelSeeds.isQuad()[pixelArrayIndex] || pixelSegments.isDup()[pixelArrayIndex]) continue; - float eta1 = pixelSegments.eta()[pixelArrayIndex]; - float phi1 = pixelSegments.phi()[pixelArrayIndex]; + float eta1 = pixelSeeds.eta()[pixelArrayIndex]; + float phi1 = pixelSeeds.phi()[pixelArrayIndex]; unsigned int prefix = ranges.segmentModuleIndices()[pixelModuleIndex]; unsigned int nTrackCandidates = cands.nTrackCandidates(); @@ -229,7 +230,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { } if (type == LSTObjType::pT3) { int pLSIndex = pixelTriplets.pixelSegmentIndices()[innerTrackletIdx]; - int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hits); + int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hitsBase); if (npMatched > 0) pixelSegments.isDup()[pixelArrayIndex] = true; @@ -245,13 +246,13 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { } if (type == LSTObjType::pT5) { unsigned int pLSIndex = innerTrackletIdx; - int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hits); + int npMatched = checkPixelHits(prefix + pixelArrayIndex, pLSIndex, mds, segments, hitsBase); if (npMatched > 0) { pixelSegments.isDup()[pixelArrayIndex] = true; } - float eta2 = pixelSegments.eta()[pLSIndex - prefix]; - float phi2 = pixelSegments.phi()[pLSIndex - prefix]; + float eta2 = pixelSeeds.eta()[pLSIndex - prefix]; + float phi2 = pixelSeeds.phi()[pLSIndex - prefix]; float dEta = alpaka::math::abs(acc, eta1 - eta2); float dPhi = cms::alpakatools::deltaPhi(acc, phi1, phi2); @@ -269,7 +270,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t nLowerModules, PixelTripletsConst pixelTriplets, TrackCandidates cands, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, ObjectRangesConst ranges) const { // implementation is 1D with a single block ALPAKA_ASSERT_ACC((alpaka::getWorkDiv(acc)[0] == 1)); @@ -303,7 +304,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelTriplets.logicalLayers()[pixelTripletIndex].data(), pixelTriplets.lowerModuleIndices()[pixelTripletIndex].data(), pixelTriplets.hitIndices()[pixelTripletIndex].data(), - pixelSegments.seedIdx()[pT3PixelIndex - pLS_offset], + pixelSeeds.seedIdx()[pT3PixelIndex - pLS_offset], __H2F(pixelTriplets.centerX()[pixelTripletIndex]), __H2F(pixelTriplets.centerY()[pixelTripletIndex]), radius, @@ -369,12 +370,12 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t nLowerModules, TrackCandidates cands, SegmentsOccupancyConst segmentsOccupancy, + PixelSeedsConst pixelSeeds, PixelSegmentsConst pixelSegments, bool tc_pls_triplets) const { unsigned int nPixels = segmentsOccupancy.nSegments()[nLowerModules]; for (unsigned int pixelArrayIndex : cms::alpakatools::uniform_elements(acc, nPixels)) { - if ((tc_pls_triplets ? 0 : !pixelSegments.isQuad()[pixelArrayIndex]) || - (pixelSegments.isDup()[pixelArrayIndex])) + if ((tc_pls_triplets ? 0 : !pixelSeeds.isQuad()[pixelArrayIndex]) || (pixelSegments.isDup()[pixelArrayIndex])) continue; unsigned int trackCandidateIdx = @@ -394,7 +395,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelArrayIndex, trackCandidateIdx, pixelSegments.pLSHitsIdxs()[pixelArrayIndex], - pixelSegments.seedIdx()[pixelArrayIndex]); + pixelSeeds.seedIdx()[pixelArrayIndex]); } } } @@ -405,7 +406,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { uint16_t nLowerModules, PixelQuintupletsConst pixelQuintuplets, TrackCandidates cands, - PixelSegmentsConst pixelSegments, + PixelSeedsConst pixelSeeds, ObjectRangesConst ranges) const { // implementation is 1D with a single block ALPAKA_ASSERT_ACC((alpaka::getWorkDiv(acc)[0] == 1)); @@ -439,7 +440,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE::lst { pixelQuintuplets.logicalLayers()[pixelQuintupletIndex].data(), pixelQuintuplets.lowerModuleIndices()[pixelQuintupletIndex].data(), pixelQuintuplets.hitIndices()[pixelQuintupletIndex].data(), - pixelSegments.seedIdx()[pT5PixelIndex - pLS_offset], + pixelSeeds.seedIdx()[pT5PixelIndex - pLS_offset], __H2F(pixelQuintuplets.centerX()[pixelQuintupletIndex]), __H2F(pixelQuintuplets.centerY()[pixelQuintupletIndex]), radius, diff --git a/RecoTracker/LSTCore/src/alpaka/classes_cuda.h b/RecoTracker/LSTCore/src/alpaka/classes_cuda.h new file mode 100644 index 0000000000000..cfc0247edac81 --- /dev/null +++ b/RecoTracker/LSTCore/src/alpaka/classes_cuda.h @@ -0,0 +1,8 @@ +#ifndef RecoTracker_LSTCore_src_alpaka_classes_cuda_h +#define RecoTracker_LSTCore_src_alpaka_classes_cuda_h + +#include "DataFormats/Common/interface/DeviceProduct.h" +#include "DataFormats/Common/interface/Wrapper.h" +#include "RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h" + +#endif diff --git a/RecoTracker/LSTCore/src/alpaka/classes_cuda_def.xml b/RecoTracker/LSTCore/src/alpaka/classes_cuda_def.xml new file mode 100644 index 0000000000000..0838995cb4517 --- /dev/null +++ b/RecoTracker/LSTCore/src/alpaka/classes_cuda_def.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/RecoTracker/LSTCore/src/alpaka/classes_rocm.h b/RecoTracker/LSTCore/src/alpaka/classes_rocm.h new file mode 100644 index 0000000000000..f507d6bfe28b7 --- /dev/null +++ b/RecoTracker/LSTCore/src/alpaka/classes_rocm.h @@ -0,0 +1,8 @@ +#ifndef RecoTracker_LSTCore_src_alpaka_classes_rocm_h +#define RecoTracker_LSTCore_src_alpaka_classes_rocm_h + +#include "DataFormats/Common/interface/DeviceProduct.h" +#include "DataFormats/Common/interface/Wrapper.h" +#include "RecoTracker/LSTCore/interface/alpaka/LSTInputDeviceCollection.h" + +#endif diff --git a/RecoTracker/LSTCore/src/alpaka/classes_rocm_def.xml b/RecoTracker/LSTCore/src/alpaka/classes_rocm_def.xml new file mode 100644 index 0000000000000..5a8f4b2ce4ca0 --- /dev/null +++ b/RecoTracker/LSTCore/src/alpaka/classes_rocm_def.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/RecoTracker/LSTCore/src/classes.cc b/RecoTracker/LSTCore/src/classes.cc new file mode 100644 index 0000000000000..fa21a778466da --- /dev/null +++ b/RecoTracker/LSTCore/src/classes.cc @@ -0,0 +1,6 @@ +#include "DataFormats/Portable/interface/PortableHostCollectionReadRules.h" +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" + +#ifndef LST_STANDALONE +SET_PORTABLEHOSTMULTICOLLECTION_READ_RULES(lst::LSTInputHostCollection); +#endif diff --git a/RecoTracker/LSTCore/src/classes.h b/RecoTracker/LSTCore/src/classes.h new file mode 100644 index 0000000000000..768762c040166 --- /dev/null +++ b/RecoTracker/LSTCore/src/classes.h @@ -0,0 +1,7 @@ +#ifndef RecoTracker_LSTCore_src_classes_h +#define RecoTracker_LSTCore_src_classes_h + +#include "DataFormats/Common/interface/Wrapper.h" +#include "RecoTracker/LSTCore/interface/LSTInputHostCollection.h" + +#endif diff --git a/RecoTracker/LSTCore/src/classes_def.xml b/RecoTracker/LSTCore/src/classes_def.xml new file mode 100644 index 0000000000000..cbbd12ca788d5 --- /dev/null +++ b/RecoTracker/LSTCore/src/classes_def.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/RecoTracker/LSTCore/standalone/Makefile b/RecoTracker/LSTCore/standalone/Makefile index 09467d22f521b..f06bf0bfffba4 100644 --- a/RecoTracker/LSTCore/standalone/Makefile +++ b/RecoTracker/LSTCore/standalone/Makefile @@ -23,12 +23,12 @@ ROCMINCLUDE = -I${ROCM_ROOT}/include ALPAKA_CPU = -DALPAKA_ACC_CPU_B_SEQ_T_SEQ_ENABLED -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 ALPAKA_CUDA = -DALPAKA_ACC_GPU_CUDA_ENABLED -DALPAKA_HOST_ONLY -DALPAKA_DISABLE_VENDOR_RNG -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 ALPAKA_ROCM = -DALPAKA_ACC_GPU_HIP_ENABLED -DALPAKA_HOST_ONLY -DALPAKA_DISABLE_VENDOR_RNG -D__HIP_PLATFORM_HCC__ -D__HIP_PLATFORM_AMD__ -DALPAKA_DEFAULT_HOST_MEMORY_ALIGNMENT=128 -EXTRAFLAGS = -ITMultiDrawTreePlayer -Wunused-variable -lTMVA -lEG -lGenVector -lXMLIO -lMLP -lTreePlayer -fopenmp +EXTRAFLAGS = -ITMultiDrawTreePlayer -Wunused-variable -lTMVA -lEG -lGenVector -lXMLIO -lMLP -lTreePlayer -fopenmp -DLST_STANDALONE DOQUINTUPLET = CUTVALUEFLAG = CUTVALUEFLAG_FLAGS = -DCUT_VALUE_DEBUG -PRIMITIVEFLAG = +PRIMITIVEFLAG = PRIMITIVEFLAG_FLAGS = -DPRIMITIVE_STUDY all: rooutil efficiency $(EXES) diff --git a/RecoTracker/LSTCore/standalone/bin/lst.cc b/RecoTracker/LSTCore/standalone/bin/lst.cc index 15be796dce378..12515593d0d22 100644 --- a/RecoTracker/LSTCore/standalone/bin/lst.cc +++ b/RecoTracker/LSTCore/standalone/bin/lst.cc @@ -1,8 +1,10 @@ #include "lst.h" +#include "LSTPrepareInput.h" #include using LSTEvent = ALPAKA_ACCELERATOR_NAMESPACE::lst::LSTEvent; +using LSTInputDeviceCollection = ALPAKA_ACCELERATOR_NAMESPACE::lst::LSTInputDeviceCollection; using namespace ::lst; //___________________________________________________________________________________________________________________________________________________________________________________________ @@ -327,29 +329,7 @@ void run_lst() { } } - std::vector> out_trkX; - std::vector> out_trkY; - std::vector> out_trkZ; - std::vector> out_hitId; - std::vector> out_hitIdxs; - std::vector> out_hitIndices_vec0; - std::vector> out_hitIndices_vec1; - std::vector> out_hitIndices_vec2; - std::vector> out_hitIndices_vec3; - std::vector> out_deltaPhi_vec; - std::vector> out_ptIn_vec; - std::vector> out_ptErr_vec; - std::vector> out_px_vec; - std::vector> out_py_vec; - std::vector> out_pz_vec; - std::vector> out_eta_vec; - std::vector> out_etaErr_vec; - std::vector> out_phi_vec; - std::vector> out_charge_vec; - std::vector> out_seedIdx_vec; - std::vector> out_superbin_vec; - std::vector> out_pixelType_vec; - std::vector> out_isQuad_vec; + std::vector out_lstInputHC; std::vector evt_num; std::vector file_name; @@ -363,29 +343,31 @@ void run_lst() { if (not goodEvent()) continue; - addInputsToLineSegmentTrackingPreLoad(out_trkX, - out_trkY, - out_trkZ, - out_hitId, - out_hitIdxs, - out_hitIndices_vec0, - out_hitIndices_vec1, - out_hitIndices_vec2, - out_hitIndices_vec3, - out_deltaPhi_vec, - out_ptIn_vec, - out_ptErr_vec, - out_px_vec, - out_py_vec, - out_pz_vec, - out_eta_vec, - out_etaErr_vec, - out_phi_vec, - out_charge_vec, - out_seedIdx_vec, - out_superbin_vec, - out_pixelType_vec, - out_isQuad_vec); + auto lstInputHC = prepareInput(trk.see_px(), + trk.see_py(), + trk.see_pz(), + trk.see_dxy(), + trk.see_dz(), + trk.see_ptErr(), + trk.see_etaErr(), + trk.see_stateTrajGlbX(), + trk.see_stateTrajGlbY(), + trk.see_stateTrajGlbZ(), + trk.see_stateTrajGlbPx(), + trk.see_stateTrajGlbPy(), + trk.see_stateTrajGlbPz(), + trk.see_q(), + trk.see_hitIdx(), + trk.see_algo(), + trk.ph2_detId(), + trk.ph2_x(), + trk.ph2_y(), + trk.ph2_z(), + ana.ptCut, + queues[0]); + + out_lstInputHC.push_back(std::move(lstInputHC)); + evt_num.push_back(ana.looper.getCurrentEventIndex()); file_name.push_back(ana.looper.getCurrentFileName()); } @@ -394,9 +376,11 @@ void run_lst() { full_timer.Reset(); full_timer.Start(); std::vector events; + std::vector event_queues; for (int s = 0; s < ana.streams; s++) { LSTEvent *event = new LSTEvent(ana.verbose >= 2, ana.ptCut, queues[s], &deviceESData); events.push_back(event); + event_queues.push_back(&queues[s]); } float timeForEventCreation = full_timer.RealTime() * 1000; @@ -418,44 +402,25 @@ void run_lst() { float timing_TC; #pragma omp for // nowait// private(event) - for (int evt = 0; evt < static_cast(out_trkX.size()); evt++) { + for (int evt = 0; evt < static_cast(out_lstInputHC.size()); evt++) { if (ana.verbose >= 1) std::cout << "Running Event number = " << evt << " " << omp_get_thread_num() << std::endl; events.at(omp_get_thread_num())->initSync(); - timing_input_loading = addInputsToEventPreLoad(events.at(omp_get_thread_num()), - false, - out_trkX.at(evt), - out_trkY.at(evt), - out_trkZ.at(evt), - out_hitId.at(evt), - out_hitIdxs.at(evt), - out_ptIn_vec.at(evt), - out_ptErr_vec.at(evt), - out_px_vec.at(evt), - out_py_vec.at(evt), - out_pz_vec.at(evt), - out_eta_vec.at(evt), - out_etaErr_vec.at(evt), - out_phi_vec.at(evt), - out_charge_vec.at(evt), - out_seedIdx_vec.at(evt), - out_superbin_vec.at(evt), - out_pixelType_vec.at(evt), - out_isQuad_vec.at(evt)); + + // We need to initialize it here so that it stays in scope + auto &queue = *event_queues.at(omp_get_thread_num()); + LSTInputDeviceCollection lstInputDC(out_lstInputHC.at(evt).sizes(), queue); + + timing_input_loading = + addInputsToEventPreLoad(events.at(omp_get_thread_num()), &out_lstInputHC.at(evt), &lstInputDC, queue); timing_MD = runMiniDoublet(events.at(omp_get_thread_num()), evt); timing_LS = runSegment(events.at(omp_get_thread_num())); timing_T3 = runT3(events.at(omp_get_thread_num())); timing_T5 = runQuintuplet(events.at(omp_get_thread_num())); - timing_pLS = runPixelLineSegment(events.at(omp_get_thread_num()), - out_hitIndices_vec0.at(evt), - out_hitIndices_vec1.at(evt), - out_hitIndices_vec2.at(evt), - out_hitIndices_vec3.at(evt), - out_deltaPhi_vec.at(evt), - ana.no_pls_dupclean); + timing_pLS = runPixelLineSegment(events.at(omp_get_thread_num()), ana.no_pls_dupclean); timing_pT5 = runPixelQuintuplet(events.at(omp_get_thread_num())); timing_pT3 = runpT3(events.at(omp_get_thread_num())); @@ -515,7 +480,7 @@ void run_lst() { timevec.insert(timevec.end(), timing_information.begin(), timing_information.end()); } - float avg_elapsed = full_elapsed / out_trkX.size(); + float avg_elapsed = full_elapsed / out_lstInputHC.size(); std::cout << "Time for map loading = " << timeForMapLoading << " ms\n"; std::cout << "Time for input loading = " << timeForInputLoading << " ms\n"; diff --git a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc index 85109d22a5127..8e075ac805abe 100644 --- a/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc +++ b/RecoTracker/LSTCore/standalone/code/core/AccessHelper.cc @@ -9,12 +9,12 @@ using namespace ALPAKA_ACCELERATOR_NAMESPACE::lst; //____________________________________________________________________________________________ std::tuple, std::vector> convertHitsToHitIdxsAndHitTypes( LSTEvent* event, std::vector hits) { - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); std::vector hitidxs; std::vector hittypes; for (auto& hit : hits) { - hitidxs.push_back(hitsEvt.idxs()[hit]); - if (hitsEvt.detid()[hit] == 1) + hitidxs.push_back(hitsBase.idxs()[hit]); + if (hitsBase.detid()[hit] == 1) hittypes.push_back(0); else hittypes.push_back(4); @@ -47,11 +47,11 @@ std::vector getPixelHitsFrompLS(LSTEvent* event, unsigned int pLS) //____________________________________________________________________________________________ std::vector getPixelHitIdxsFrompLS(LSTEvent* event, unsigned int pLS) { - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); std::vector hits = getPixelHitsFrompLS(event, pLS); std::vector hitidxs; for (auto& hit : hits) - hitidxs.push_back(hitsEvt.idxs()[hit]); + hitidxs.push_back(hitsBase.idxs()[hit]); return hitidxs; } @@ -190,18 +190,18 @@ std::vector getHitsFromT5(LSTEvent* event, unsigned int T5) { //____________________________________________________________________________________________ std::vector getHitIdxsFromT5(LSTEvent* event, unsigned int T5) { - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); std::vector hits = getHitsFromT5(event, T5); std::vector hitidxs; for (auto& hit : hits) - hitidxs.push_back(hitsEvt.idxs()[hit]); + hitidxs.push_back(hitsBase.idxs()[hit]); return hitidxs; } //____________________________________________________________________________________________ std::vector getModuleIdxsFromT5(LSTEvent* event, unsigned int T5) { std::vector hits = getHitsFromT5(event, T5); std::vector module_idxs; - auto hitsEvt = event->getHits(); + auto hitsEvt = event->getHits(); for (auto& hitIdx : hits) { module_idxs.push_back(hitsEvt.moduleIndices()[hitIdx]); } @@ -212,7 +212,7 @@ std::vector getModuleIdxsFromT5(LSTEvent* event, unsigned int T5) std::vector getModuleIdxsFromT3(LSTEvent* event, unsigned int T3) { std::vector hits = getHitsFromT3(event, T3); std::vector module_idxs; - auto hitsEvt = event->getHits(); + auto hitsEvt = event->getHits(); for (auto& hitIdx : hits) { module_idxs.push_back(hitsEvt.moduleIndices()[hitIdx]); } @@ -286,18 +286,18 @@ std::vector getHitsFrompT3(LSTEvent* event, unsigned int pT3) { //____________________________________________________________________________________________ std::vector getHitIdxsFrompT3(LSTEvent* event, unsigned int pT3) { - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); std::vector hits = getHitsFrompT3(event, pT3); std::vector hitidxs; for (auto& hit : hits) - hitidxs.push_back(hitsEvt.idxs()[hit]); + hitidxs.push_back(hitsBase.idxs()[hit]); return hitidxs; } //____________________________________________________________________________________________ std::vector getModuleIdxsFrompT3(LSTEvent* event, unsigned int pT3) { std::vector hits = getOuterTrackerHitsFrompT3(event, pT3); std::vector module_idxs; - auto hitsEvt = event->getHits(); + auto hitsEvt = event->getHits(); for (auto& hitIdx : hits) { module_idxs.push_back(hitsEvt.moduleIndices()[hitIdx]); } @@ -381,11 +381,11 @@ std::vector getHitsFrompT5(LSTEvent* event, unsigned int pT5) { //____________________________________________________________________________________________ std::vector getHitIdxsFrompT5(LSTEvent* event, unsigned int pT5) { - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); std::vector hits = getHitsFrompT5(event, pT5); std::vector hitidxs; for (auto& hit : hits) - hitidxs.push_back(hitsEvt.idxs()[hit]); + hitidxs.push_back(hitsBase.idxs()[hit]); return hitidxs; } @@ -393,7 +393,7 @@ std::vector getHitIdxsFrompT5(LSTEvent* event, unsigned int pT5) { std::vector getModuleIdxsFrompT5(LSTEvent* event, unsigned int pT5) { std::vector hits = getOuterTrackerHitsFrompT5(event, pT5); std::vector module_idxs; - auto hitsEvt = event->getHits(); + auto hitsEvt = event->getHits(); for (auto& hitIdx : hits) { module_idxs.push_back(hitsEvt.moduleIndices()[hitIdx]); } diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc index b9b77a3353e71..faa1ab2aa9b05 100644 --- a/RecoTracker/LSTCore/standalone/code/core/trkCore.cc +++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.cc @@ -216,19 +216,12 @@ float runQuintuplet(LSTEvent *event) { } //___________________________________________________________________________________________________________________________________________________________________________________________ -float runPixelLineSegment(LSTEvent *event, - std::vector hitIndices_vec0, - std::vector hitIndices_vec1, - std::vector hitIndices_vec2, - std::vector hitIndices_vec3, - std::vector deltaPhi_vec, - bool no_pls_dupclean) { +float runPixelLineSegment(LSTEvent *event, bool no_pls_dupclean) { TStopwatch my_timer; if (ana.verbose >= 2) std::cout << "Reco Pixel Line Segment start" << std::endl; my_timer.Start(); - event->addPixelSegmentToEventFinalize( - hitIndices_vec0, hitIndices_vec1, hitIndices_vec2, hitIndices_vec3, deltaPhi_vec); + event->addPixelSegmentToEventFinalize(); event->pixelLineSegmentCleaning(no_pls_dupclean); event->wait(); // device side event calls are asynchronous: wait to measure time or print float pls_elapsed = my_timer.RealTime(); @@ -606,281 +599,11 @@ TVector3 calculateR3FromPCA(const TVector3 &p3, const float dxy, const float dz) // ---------------------------------- =========================================== ---------------------------------------------- // ---------------------------------- =========================================== ---------------------------------------------- -//___________________________________________________________________________________________________________________________________________________________________________________________ -void addInputsToLineSegmentTrackingPreLoad(std::vector> &out_trkX, - std::vector> &out_trkY, - std::vector> &out_trkZ, - std::vector> &out_hitId, - std::vector> &out_hitIdxs, - std::vector> &out_hitIndices_vec0, - std::vector> &out_hitIndices_vec1, - std::vector> &out_hitIndices_vec2, - std::vector> &out_hitIndices_vec3, - std::vector> &out_deltaPhi_vec, - std::vector> &out_ptIn_vec, - std::vector> &out_ptErr_vec, - std::vector> &out_px_vec, - std::vector> &out_py_vec, - std::vector> &out_pz_vec, - std::vector> &out_eta_vec, - std::vector> &out_etaErr_vec, - std::vector> &out_phi_vec, - std::vector> &out_charge_vec, - std::vector> &out_seedIdx_vec, - std::vector> &out_superbin_vec, - std::vector> &out_pixelType_vec, - std::vector> &out_isQuad_vec) { - unsigned int count = 0; - auto n_see = trk.see_stateTrajGlbPx().size(); - std::vector px_vec; - px_vec.reserve(n_see); - std::vector py_vec; - py_vec.reserve(n_see); - std::vector pz_vec; - pz_vec.reserve(n_see); - std::vector hitIndices_vec0; - hitIndices_vec0.reserve(n_see); - std::vector hitIndices_vec1; - hitIndices_vec1.reserve(n_see); - std::vector hitIndices_vec2; - hitIndices_vec2.reserve(n_see); - std::vector hitIndices_vec3; - hitIndices_vec3.reserve(n_see); - std::vector ptIn_vec; - ptIn_vec.reserve(n_see); - std::vector ptErr_vec; - ptErr_vec.reserve(n_see); - std::vector etaErr_vec; - etaErr_vec.reserve(n_see); - std::vector eta_vec; - eta_vec.reserve(n_see); - std::vector phi_vec; - phi_vec.reserve(n_see); - std::vector charge_vec; - charge_vec.reserve(n_see); - std::vector seedIdx_vec; - seedIdx_vec.reserve(n_see); - std::vector deltaPhi_vec; - deltaPhi_vec.reserve(n_see); - std::vector trkX = trk.ph2_x(); - std::vector trkY = trk.ph2_y(); - std::vector trkZ = trk.ph2_z(); - std::vector hitId = trk.ph2_detId(); - std::vector hitIdxs(trk.ph2_detId().size()); - - std::vector superbin_vec; - std::vector pixelType_vec; - std::vector isQuad_vec; - std::iota(hitIdxs.begin(), hitIdxs.end(), 0); - const int hit_size = trkX.size(); - - for (size_t iSeed = 0; iSeed < trk.see_stateTrajGlbPx().size(); ++iSeed) { - //// track algorithm; partial copy from TrackBase.h - // enum class TrackAlgorithm { - // undefAlgorithm = 0, - // ctf = 1, - // duplicateMerge = 2, - // cosmics = 3, - // initialStep = 4, - // lowPtTripletStep = 5, - // pixelPairStep = 6, - // detachedTripletStep = 7, - // mixedTripletStep = 8, - // pixelLessStep = 9, - // tobTecStep = 10, - // jetCoreRegionalStep = 11, - // conversionStep = 12, - // muonSeededStepInOut = 13, - // muonSeededStepOutIn = 14, - // outInEcalSeededConv = 15, inOutEcalSeededConv = 16, - // nuclInter = 17, - // standAloneMuon = 18, globalMuon = 19, cosmicStandAloneMuon = 20, cosmicGlobalMuon = 21, - // // Phase1 - // highPtTripletStep = 22, lowPtQuadStep = 23, detachedQuadStep = 24, - // reservedForUpgrades1 = 25, reservedForUpgrades2 = 26, - // bTagGhostTracks = 27, - // beamhalo = 28, - // gsf = 29 - //}; - bool good_seed_type = false; - if (trk.see_algo()[iSeed] == 4) - good_seed_type = true; - // if (trk.see_algo()[iSeed] == 5) good_seed_type = true; - // if (trk.see_algo()[iSeed] == 7) good_seed_type = true; - if (trk.see_algo()[iSeed] == 22) - good_seed_type = true; - // if (trk.see_algo()[iSeed] == 23) good_seed_type = true; - // if (trk.see_algo()[iSeed] == 24) good_seed_type = true; - if (not good_seed_type) - continue; - - TVector3 p3LH(trk.see_stateTrajGlbPx()[iSeed], trk.see_stateTrajGlbPy()[iSeed], trk.see_stateTrajGlbPz()[iSeed]); - float ptIn = p3LH.Pt(); - float eta = p3LH.Eta(); - float ptErr = trk.see_ptErr()[iSeed]; - - if ((ptIn > ana.ptCut - 2 * ptErr)) { - TVector3 r3LH(trk.see_stateTrajGlbX()[iSeed], trk.see_stateTrajGlbY()[iSeed], trk.see_stateTrajGlbZ()[iSeed]); - TVector3 p3PCA(trk.see_px()[iSeed], trk.see_py()[iSeed], trk.see_pz()[iSeed]); - TVector3 r3PCA(calculateR3FromPCA(p3PCA, trk.see_dxy()[iSeed], trk.see_dz()[iSeed])); - TVector3 seedSD_mdRef_r3 = r3PCA; - TVector3 seedSD_mdOut_r3 = r3LH; - TVector3 seedSD_r3 = r3LH; - TVector3 seedSD_p3 = p3LH; - - // The charge could be used directly in the line below - float pixelSegmentDeltaPhiChange = r3LH.DeltaPhi(p3LH); - float etaErr = trk.see_etaErr()[iSeed]; - float px = p3LH.X(); - float py = p3LH.Y(); - float pz = p3LH.Z(); - int charge = trk.see_q()[iSeed]; - unsigned int seedIdx = iSeed; - - PixelType pixtype = PixelType::kInvalid; - if (ptIn >= 2.0) { - pixtype = PixelType::kHighPt; - } else if (ptIn >= (ana.ptCut - 2 * ptErr) and ptIn < 2.0) { - if (pixelSegmentDeltaPhiChange >= 0) { - pixtype = PixelType::kLowPtPosCurv; - } else { - pixtype = PixelType::kLowPtNegCurv; - } - } else { - continue; - } - - unsigned int hitIdx0 = hit_size + count; - count++; - - unsigned int hitIdx1 = hit_size + count; - count++; - - unsigned int hitIdx2 = hit_size + count; - count++; - - unsigned int hitIdx3; - if (trk.see_hitIdx()[iSeed].size() <= 3) { - hitIdx3 = hitIdx2; - } else { - hitIdx3 = hit_size + count; - count++; - } - - trkX.push_back(r3PCA.X()); - trkY.push_back(r3PCA.Y()); - trkZ.push_back(r3PCA.Z()); - trkX.push_back(p3PCA.Pt()); - float p3PCA_Eta = p3PCA.Eta(); - trkY.push_back(p3PCA_Eta); - float p3PCA_Phi = p3PCA.Phi(); - trkZ.push_back(p3PCA_Phi); - trkX.push_back(r3LH.X()); - trkY.push_back(r3LH.Y()); - trkZ.push_back(r3LH.Z()); - hitId.push_back(1); - hitId.push_back(1); - hitId.push_back(1); - if (trk.see_hitIdx()[iSeed].size() > 3) { - trkX.push_back(r3LH.X()); - trkY.push_back(trk.see_dxy()[iSeed]); - trkZ.push_back(trk.see_dz()[iSeed]); - hitId.push_back(1); - } - px_vec.push_back(px); - py_vec.push_back(py); - pz_vec.push_back(pz); - - hitIndices_vec0.push_back(hitIdx0); - hitIndices_vec1.push_back(hitIdx1); - hitIndices_vec2.push_back(hitIdx2); - hitIndices_vec3.push_back(hitIdx3); - ptIn_vec.push_back(ptIn); - ptErr_vec.push_back(ptErr); - etaErr_vec.push_back(etaErr); - eta_vec.push_back(eta); - float phi = p3LH.Phi(); - phi_vec.push_back(phi); - charge_vec.push_back(charge); - seedIdx_vec.push_back(seedIdx); - deltaPhi_vec.push_back(pixelSegmentDeltaPhiChange); - - // For matching with sim tracks - hitIdxs.push_back(trk.see_hitIdx()[iSeed][0]); - hitIdxs.push_back(trk.see_hitIdx()[iSeed][1]); - hitIdxs.push_back(trk.see_hitIdx()[iSeed][2]); - char isQuad = false; - if (trk.see_hitIdx()[iSeed].size() > 3) { - isQuad = true; - hitIdxs.push_back(trk.see_hitIdx()[iSeed].size() > 3 ? trk.see_hitIdx()[iSeed][3] : trk.see_hitIdx()[iSeed][2]); - } - // if (pt < 0){ ptbin = 0;} - float neta = 25.; - float nphi = 72.; - float nz = 25.; - int etabin = (p3PCA_Eta + 2.6) / ((2 * 2.6) / neta); - int phibin = (p3PCA_Phi + 3.14159265358979323846) / ((2. * 3.14159265358979323846) / nphi); - int dzbin = (trk.see_dz()[iSeed] + 30) / (2 * 30 / nz); - int isuperbin = - /*(nz * nphi * neta) * ptbin + (removed since pt bin is determined by pixelType)*/ (nz * nphi) * etabin + - (nz)*phibin + dzbin; - // if(isuperbin<0 || isuperbin>=44900){printf("isuperbin %d %d %d %d %f\n",isuperbin,etabin,phibin,dzbin,p3PCA.Eta());} - superbin_vec.push_back(isuperbin); - pixelType_vec.push_back(pixtype); - isQuad_vec.push_back(isQuad); - } - } - - out_trkX.push_back(trkX); - out_trkY.push_back(trkY); - out_trkZ.push_back(trkZ); - out_hitId.push_back(hitId); - out_hitIdxs.push_back(hitIdxs); - out_hitIndices_vec0.push_back(hitIndices_vec0); - out_hitIndices_vec1.push_back(hitIndices_vec1); - out_hitIndices_vec2.push_back(hitIndices_vec2); - out_hitIndices_vec3.push_back(hitIndices_vec3); - out_deltaPhi_vec.push_back(deltaPhi_vec); - out_ptIn_vec.push_back(ptIn_vec); - out_ptErr_vec.push_back(ptErr_vec); - out_px_vec.push_back(px_vec); - out_py_vec.push_back(py_vec); - out_pz_vec.push_back(pz_vec); - out_eta_vec.push_back(eta_vec); - out_etaErr_vec.push_back(etaErr_vec); - out_phi_vec.push_back(phi_vec); - out_charge_vec.push_back(charge_vec); - out_seedIdx_vec.push_back(seedIdx_vec); - out_superbin_vec.push_back(superbin_vec); - out_pixelType_vec.push_back(pixelType_vec); - out_isQuad_vec.push_back(isQuad_vec); - - // float hit_loading_elapsed = my_timer.RealTime(); - // if (ana.verbose >= 2) std::cout << "Loading inputs processing time: " << hit_loading_elapsed << " secs" << std::endl; - // return hit_loading_elapsed; -} - //___________________________________________________________________________________________________________________________________________________________________________________________ float addInputsToEventPreLoad(LSTEvent *event, - bool useOMP, - std::vector trkX, - std::vector trkY, - std::vector trkZ, - std::vector hitId, - std::vector hitIdxs, - std::vector ptIn_vec, - std::vector ptErr_vec, - std::vector px_vec, - std::vector py_vec, - std::vector pz_vec, - std::vector eta_vec, - std::vector etaErr_vec, - std::vector phi_vec, - std::vector charge_vec, - std::vector seedIdx_vec, - std::vector superbin_vec, - std::vector pixelType_vec, - std::vector isQuad_vec) { + lst::LSTInputHostCollection *lstInputHC, + LSTInputDeviceCollection *lstInputDC, + ALPAKA_ACCELERATOR_NAMESPACE::Queue &queue) { TStopwatch my_timer; if (ana.verbose >= 2) @@ -889,21 +612,14 @@ float addInputsToEventPreLoad(LSTEvent *event, my_timer.Start(); - event->addHitToEvent(trkX, trkY, trkZ, hitId, hitIdxs); - - event->addPixelSegmentToEventStart(ptIn_vec, - ptErr_vec, - px_vec, - py_vec, - pz_vec, - eta_vec, - etaErr_vec, - phi_vec, - charge_vec, - seedIdx_vec, - superbin_vec, - pixelType_vec, - isQuad_vec); + // We can't use CopyToDevice because the device can be DevHost + alpaka::memcpy(queue, lstInputDC->buffer(), lstInputHC->buffer()); + alpaka::wait(queue); + + event->addInputToEvent(lstInputDC); + event->addHitToEvent(); + + event->addPixelSegmentToEventStart(); event->wait(); // device side event calls are asynchronous: wait to measure time or print float hit_loading_elapsed = my_timer.RealTime(); diff --git a/RecoTracker/LSTCore/standalone/code/core/trkCore.h b/RecoTracker/LSTCore/standalone/code/core/trkCore.h index b3abdcc09d672..31b3a9f96fdb4 100644 --- a/RecoTracker/LSTCore/standalone/code/core/trkCore.h +++ b/RecoTracker/LSTCore/standalone/code/core/trkCore.h @@ -13,6 +13,7 @@ #include using LSTEvent = ALPAKA_ACCELERATOR_NAMESPACE::lst::LSTEvent; +using LSTInputDeviceCollection = ALPAKA_ACCELERATOR_NAMESPACE::lst::LSTInputDeviceCollection; using ::lst::PixelType; // --------------------- ======================== --------------------- @@ -27,13 +28,7 @@ float runT3(LSTEvent *event); float runTrackCandidate(LSTEvent *event, bool no_pls_dupclean, bool tc_pls_triplets); float runQuintuplet(LSTEvent *event); float runPixelQuintuplet(LSTEvent *event); -float runPixelLineSegment(LSTEvent *event, - std::vector hitIndices_vec0, - std::vector hitIndices_vec1, - std::vector hitIndices_vec2, - std::vector hitIndices_vec3, - std::vector deltaPhi_vec, - bool no_pls_dupclean); +float runPixelLineSegment(LSTEvent *event, bool no_pls_dupclean); float runpT3(LSTEvent *event); // --------------------- ======================== --------------------- @@ -56,50 +51,10 @@ TVector3 calculateR3FromPCA(const TVector3 &p3, const float dxy, const float dz) // --------------------- ======================== --------------------- -void addInputsToLineSegmentTrackingPreLoad(std::vector> &out_trkX, - std::vector> &out_trkY, - std::vector> &out_trkZ, - std::vector> &out_hitId, - std::vector> &out_hitIdxs, - std::vector> &out_hitIndices_vec0, - std::vector> &out_hitIndices_vec1, - std::vector> &out_hitIndices_vec2, - std::vector> &out_hitIndices_vec3, - std::vector> &out_deltaPhi_vec, - std::vector> &out_ptIn_vec, - std::vector> &out_ptErr_vec, - std::vector> &out_px_vec, - std::vector> &out_py_vec, - std::vector> &out_pz_vec, - std::vector> &out_eta_vec, - std::vector> &out_etaErr_vec, - std::vector> &out_phi_vec, - std::vector> &out_charge_vec, - std::vector> &out_seedIdx_vec, - std::vector> &out_superbin_vec, - std::vector> &out_pixelType_vec, - std::vector> &out_isQuad_vec); - float addInputsToEventPreLoad(LSTEvent *event, - bool useOMP, - std::vector trkX, - std::vector trkY, - std::vector trkZ, - std::vector hitId, - std::vector hitIdxs, - std::vector ptIn_vec, - std::vector ptErr_vec, - std::vector px_vec, - std::vector py_vec, - std::vector pz_vec, - std::vector eta_vec, - std::vector etaErr_vec, - std::vector phi_vec, - std::vector charge_vec, - std::vector seedIdx_vec, - std::vector superbin_vec, - std::vector pixelType_vec, - std::vector isQuad_vec); + lst::LSTInputHostCollection *lstInputHC, + LSTInputDeviceCollection *lstInputDC, + ALPAKA_ACCELERATOR_NAMESPACE::Queue &queue); void printTimingInformation(std::vector> &timing_information, float fullTime, float fullavg); diff --git a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc index d832207f23c44..62fdefb68d921 100644 --- a/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc +++ b/RecoTracker/LSTCore/standalone/code/core/write_lst_ntuple.cc @@ -447,7 +447,7 @@ void setPixelQuintupletOutputBranches(LSTEvent* event) { // ============ pT5 ============= auto const pixelQuintuplets = event->getPixelQuintuplets(); auto const quintuplets = event->getQuintuplets(); - auto const pixelSegments = event->getPixelSegments(); + auto const pixelSeeds = event->getInput(); auto modules = event->getModules(); int n_accepted_simtrk = ana.tx->getBranch>("sim_TC_matched").size(); @@ -458,9 +458,9 @@ void setPixelQuintupletOutputBranches(LSTEvent* event) { for (unsigned int pT5 = 0; pT5 < nPixelQuintuplets; pT5++) { unsigned int T5Index = getT5FrompT5(event, pT5); unsigned int pLSIndex = getPixelLSFrompT5(event, pT5); - float pt = (__H2F(quintuplets.innerRadius()[T5Index]) * k2Rinv1GeVf * 2 + pixelSegments.ptIn()[pLSIndex]) / 2; - float eta = pixelSegments.eta()[pLSIndex]; - float phi = pixelSegments.phi()[pLSIndex]; + float pt = (__H2F(quintuplets.innerRadius()[T5Index]) * k2Rinv1GeVf * 2 + pixelSeeds.ptIn()[pLSIndex]) / 2; + float eta = pixelSeeds.eta()[pLSIndex]; + float phi = pixelSeeds.phi()[pLSIndex]; std::vector hit_idx = getHitIdxsFrompT5(event, pT5); std::vector module_idx = getModuleIdxsFrompT5(event, pT5); @@ -614,7 +614,7 @@ void setQuintupletOutputBranches(LSTEvent* event) { void setPixelTripletOutputBranches(LSTEvent* event) { auto const pixelTriplets = event->getPixelTriplets(); auto modules = event->getModules(); - PixelSegmentsConst pixelSegments = event->getPixelSegments(); + PixelSeedsConst pixelSeeds = event->getInput(); int n_accepted_simtrk = ana.tx->getBranch>("sim_TC_matched").size(); unsigned int nPixelTriplets = pixelTriplets.nPixelTriplets(); @@ -624,10 +624,10 @@ void setPixelTripletOutputBranches(LSTEvent* event) { for (unsigned int pT3 = 0; pT3 < nPixelTriplets; pT3++) { unsigned int T3Index = getT3FrompT3(event, pT3); unsigned int pLSIndex = getPixelLSFrompT3(event, pT3); - const float pt = pixelSegments.ptIn()[pLSIndex]; + const float pt = pixelSeeds.ptIn()[pLSIndex]; - float eta = pixelSegments.eta()[pLSIndex]; - float phi = pixelSegments.phi()[pLSIndex]; + float eta = pixelSeeds.eta()[pLSIndex]; + float phi = pixelSeeds.phi()[pLSIndex]; std::vector hit_idx = getHitIdxsFrompT3(event, pT3); std::vector hit_type = getHitTypesFrompT3(event, pT3); @@ -675,7 +675,8 @@ void setPixelTripletOutputBranches(LSTEvent* event) { //________________________________________________________________________________________________________________________________ void fillT3DNNBranches(LSTEvent* event, unsigned int iT3) { - auto hits = event->getHits(); + auto hitsBase = event->getInput(); + auto hitsExtended = event->getHits(); auto modules = event->getModules(); std::vector hitIdx = getHitsFromT3(event, iT3); @@ -683,9 +684,9 @@ void fillT3DNNBranches(LSTEvent* event, unsigned int iT3) { for (int i = 0; i < hitIdx.size(); ++i) { unsigned int hit = hitIdx[i]; - float x = hits.xs()[hit]; - float y = hits.ys()[hit]; - float z = hits.zs()[hit]; + float x = hitsBase.xs()[hit]; + float y = hitsBase.ys()[hit]; + float z = hitsBase.zs()[hit]; lst_math::Hit hitObj(x, y, z); hitObjects.push_back(hitObj); @@ -697,11 +698,11 @@ void fillT3DNNBranches(LSTEvent* event, unsigned int iT3) { ana.tx->pushbackToBranch("t3_hit_" + idx + "_eta", hitObj.eta()); ana.tx->pushbackToBranch("t3_hit_" + idx + "_phi", hitObj.phi()); - int subdet = trk.ph2_subdet()[hits.idxs()[hit]]; + int subdet = trk.ph2_subdet()[hitsBase.idxs()[hit]]; int is_endcap = subdet == 4; - int layer = trk.ph2_layer()[hits.idxs()[hit]] + 6 * is_endcap; - int detId = trk.ph2_detId()[hits.idxs()[hit]]; - unsigned int module = hits.moduleIndices()[hit]; + int layer = trk.ph2_layer()[hitsBase.idxs()[hit]] + 6 * is_endcap; + int detId = trk.ph2_detId()[hitsBase.idxs()[hit]]; + unsigned int module = hitsExtended.moduleIndices()[hit]; ana.tx->pushbackToBranch("t3_hit_" + idx + "_detId", detId); ana.tx->pushbackToBranch("t3_hit_" + idx + "_layer", layer); @@ -711,7 +712,8 @@ void fillT3DNNBranches(LSTEvent* event, unsigned int iT3) { //________________________________________________________________________________________________________________________________ void fillT5DNNBranches(LSTEvent* event, unsigned int iT3) { - auto hits = event->getHits(); + auto hitsBase = event->getInput(); + auto hitsExtended = event->getHits(); auto modules = event->getModules(); std::vector hitIdx = getHitsFromT3(event, iT3); @@ -719,9 +721,9 @@ void fillT5DNNBranches(LSTEvent* event, unsigned int iT3) { for (int i = 0; i < hitIdx.size(); ++i) { unsigned int hit = hitIdx[i]; - float x = hits.xs()[hit]; - float y = hits.ys()[hit]; - float z = hits.zs()[hit]; + float x = hitsBase.xs()[hit]; + float y = hitsBase.ys()[hit]; + float z = hitsBase.zs()[hit]; hitObjects[i] = lst_math::Hit(x, y, z); std::string idx = std::to_string(i); @@ -732,11 +734,11 @@ void fillT5DNNBranches(LSTEvent* event, unsigned int iT3) { ana.tx->pushbackToBranch("t5_t3_" + idx + "_eta", hitObjects[i].eta()); ana.tx->pushbackToBranch("t5_t3_" + idx + "_phi", hitObjects[i].phi()); - int subdet = trk.ph2_subdet()[hits.idxs()[hit]]; + int subdet = trk.ph2_subdet()[hitsBase.idxs()[hit]]; int is_endcap = subdet == 4; - int layer = trk.ph2_layer()[hits.idxs()[hit]] + 6 * is_endcap; - int detId = trk.ph2_detId()[hits.idxs()[hit]]; - unsigned int module = hits.moduleIndices()[hit]; + int layer = trk.ph2_layer()[hitsBase.idxs()[hit]] + 6 * is_endcap; + int detId = trk.ph2_detId()[hitsBase.idxs()[hit]]; + unsigned int module = hitsExtended.moduleIndices()[hit]; ana.tx->pushbackToBranch("t5_t3_" + idx + "_detId", detId); ana.tx->pushbackToBranch("t5_t3_" + idx + "_layer", layer); @@ -878,7 +880,7 @@ void setGnnNtupleBranches(LSTEvent* event) { // Get relevant information SegmentsOccupancyConst segmentsOccupancy = event->getSegments(); MiniDoubletsOccupancyConst miniDoublets = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); auto modules = event->getModules(); auto ranges = event->getRanges(); auto const& trackCandidates = event->getTrackCandidates(); @@ -957,8 +959,8 @@ void setGnnNtupleBranches(LSTEvent* event) { // Computing line segment pt estimate (assuming beam spot is at zero) lst_math::Hit hitA(0, 0, 0); - lst_math::Hit hitB(hitsEvt.xs()[hits[0]], hitsEvt.ys()[hits[0]], hitsEvt.zs()[hits[0]]); - lst_math::Hit hitC(hitsEvt.xs()[hits[2]], hitsEvt.ys()[hits[2]], hitsEvt.zs()[hits[2]]); + lst_math::Hit hitB(hitsBase.xs()[hits[0]], hitsBase.ys()[hits[0]], hitsBase.zs()[hits[0]]); + lst_math::Hit hitC(hitsBase.xs()[hits[2]], hitsBase.ys()[hits[2]], hitsBase.zs()[hits[2]]); lst_math::Hit center = lst_math::getCenterFromThreePoints(hitA, hitB, hitC); float pt = lst_math::ptEstimateFromRadius(center.rt()); float eta = hitC.eta(); @@ -1018,24 +1020,24 @@ void setGnnNtupleBranches(LSTEvent* event) { void setGnnNtupleMiniDoublet(LSTEvent* event, unsigned int MD) { // Get relevant information MiniDoubletsConst miniDoublets = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); // Get the hit indices unsigned int hit0 = miniDoublets.anchorHitIndices()[MD]; unsigned int hit1 = miniDoublets.outerHitIndices()[MD]; // Get the hit infos - const float hit0_x = hitsEvt.xs()[hit0]; - const float hit0_y = hitsEvt.ys()[hit0]; - const float hit0_z = hitsEvt.zs()[hit0]; + const float hit0_x = hitsBase.xs()[hit0]; + const float hit0_y = hitsBase.ys()[hit0]; + const float hit0_z = hitsBase.zs()[hit0]; const float hit0_r = sqrt(hit0_x * hit0_x + hit0_y * hit0_y); - const float hit1_x = hitsEvt.xs()[hit1]; - const float hit1_y = hitsEvt.ys()[hit1]; - const float hit1_z = hitsEvt.zs()[hit1]; + const float hit1_x = hitsBase.xs()[hit1]; + const float hit1_y = hitsBase.ys()[hit1]; + const float hit1_z = hitsBase.zs()[hit1]; const float hit1_r = sqrt(hit1_x * hit1_x + hit1_y * hit1_y); // Do sim matching - std::vector hit_idx = {hitsEvt.idxs()[hit0], hitsEvt.idxs()[hit1]}; + std::vector hit_idx = {hitsBase.idxs()[hit0], hitsBase.idxs()[hit1]}; std::vector hit_type = {4, 4}; std::vector simidxs = matchedSimTrkIdxs(hit_idx, hit_type); @@ -1043,8 +1045,8 @@ void setGnnNtupleMiniDoublet(LSTEvent* event, unsigned int MD) { int tp_type = getDenomSimTrkType(simidxs); // Obtain where the actual hit is located in terms of their layer, module, rod, and ring number - unsigned int anchitidx = hitsEvt.idxs()[hit0]; - int subdet = trk.ph2_subdet()[hitsEvt.idxs()[anchitidx]]; + unsigned int anchitidx = hitsBase.idxs()[hit0]; + int subdet = trk.ph2_subdet()[hitsBase.idxs()[anchitidx]]; int is_endcap = subdet == 4; int layer = trk.ph2_layer()[anchitidx] + @@ -1119,7 +1121,7 @@ std::tuple, std::vectorgetTrackCandidates(); auto const quintuplets = event->getQuintuplets(); - auto const pixelSegments = event->getPixelSegments(); + auto const pixelSeeds = event->getInput(); // // pictorial representation of a pT5 @@ -1212,9 +1214,9 @@ std::tuple, std::vector, std::vectorgetTrackCandidates(); auto const triplets = event->getTriplets(); - auto const pixelSegments = event->getPixelSegments(); + auto const pixelSeeds = event->getInput(); // // pictorial representation of a pT3 @@ -1245,9 +1247,9 @@ std::tuple, std::vector, std::vector, std::vector> parsepLS(LSTEvent* event, unsigned int idx) { auto const& trackCandidates = event->getTrackCandidates(); - PixelSegmentsConst pixelSegments = event->getPixelSegments(); + auto pixelSeeds = event->getInput(); // Getting pLS index unsigned int pLS = trackCandidates.directObjectIndices()[idx]; // Getting pt eta and phi - float pt = pixelSegments.ptIn()[pLS]; - float eta = pixelSegments.eta()[pLS]; - float phi = pixelSegments.phi()[pLS]; + float pt = pixelSeeds.ptIn()[pLS]; + float eta = pixelSeeds.eta()[pLS]; + float phi = pixelSeeds.phi()[pLS]; // Getting hit indices and types std::vector hit_idx = getPixelHitIdxsFrompLS(event, pLS); @@ -1361,7 +1363,7 @@ void printAllObjects(LSTEvent* event) { void printMDs(LSTEvent* event) { MiniDoubletsConst miniDoublets = event->getMiniDoublets(); MiniDoubletsOccupancyConst miniDoubletsOccupancy = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); auto modules = event->getModules(); auto ranges = event->getRanges(); @@ -1371,8 +1373,8 @@ void printMDs(LSTEvent* event) { unsigned int mdIdx = ranges.miniDoubletModuleIndices()[idx] + iMD; unsigned int LowerHitIndex = miniDoublets.anchorHitIndices()[mdIdx]; unsigned int UpperHitIndex = miniDoublets.outerHitIndices()[mdIdx]; - unsigned int hit0 = hitsEvt.idxs()[LowerHitIndex]; - unsigned int hit1 = hitsEvt.idxs()[UpperHitIndex]; + unsigned int hit0 = hitsBase.idxs()[LowerHitIndex]; + unsigned int hit1 = hitsBase.idxs()[UpperHitIndex]; std::cout << "VALIDATION 'MD': " << "MD" << " hit0: " << hit0 << " hit1: " << hit1 << std::endl; @@ -1385,7 +1387,7 @@ void printLSs(LSTEvent* event) { SegmentsConst segments = event->getSegments(); SegmentsOccupancyConst segmentsOccupancy = event->getSegments(); MiniDoubletsConst miniDoublets = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); auto modules = event->getModules(); auto ranges = event->getRanges(); @@ -1401,10 +1403,10 @@ void printLSs(LSTEvent* event) { unsigned int InnerMiniDoubletUpperHitIndex = miniDoublets.outerHitIndices()[InnerMiniDoubletIndex]; unsigned int OuterMiniDoubletLowerHitIndex = miniDoublets.anchorHitIndices()[OuterMiniDoubletIndex]; unsigned int OuterMiniDoubletUpperHitIndex = miniDoublets.outerHitIndices()[OuterMiniDoubletIndex]; - unsigned int hit0 = hitsEvt.idxs()[InnerMiniDoubletLowerHitIndex]; - unsigned int hit1 = hitsEvt.idxs()[InnerMiniDoubletUpperHitIndex]; - unsigned int hit2 = hitsEvt.idxs()[OuterMiniDoubletLowerHitIndex]; - unsigned int hit3 = hitsEvt.idxs()[OuterMiniDoubletUpperHitIndex]; + unsigned int hit0 = hitsBase.idxs()[InnerMiniDoubletLowerHitIndex]; + unsigned int hit1 = hitsBase.idxs()[InnerMiniDoubletUpperHitIndex]; + unsigned int hit2 = hitsBase.idxs()[OuterMiniDoubletLowerHitIndex]; + unsigned int hit3 = hitsBase.idxs()[OuterMiniDoubletUpperHitIndex]; std::cout << "VALIDATION 'LS': " << "LS" << " hit0: " << hit0 << " hit1: " << hit1 << " hit2: " << hit2 << " hit3: " << hit3 << std::endl; @@ -1418,7 +1420,7 @@ void printpLSs(LSTEvent* event) { SegmentsConst segments = event->getSegments(); SegmentsOccupancyConst segmentsOccupancy = event->getSegments(); MiniDoubletsConst miniDoublets = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); auto modules = event->getModules(); auto ranges = event->getRanges(); @@ -1433,10 +1435,10 @@ void printpLSs(LSTEvent* event) { unsigned int InnerMiniDoubletUpperHitIndex = miniDoublets.outerHitIndices()[InnerMiniDoubletIndex]; unsigned int OuterMiniDoubletLowerHitIndex = miniDoublets.anchorHitIndices()[OuterMiniDoubletIndex]; unsigned int OuterMiniDoubletUpperHitIndex = miniDoublets.outerHitIndices()[OuterMiniDoubletIndex]; - unsigned int hit0 = hitsEvt.idxs()[InnerMiniDoubletLowerHitIndex]; - unsigned int hit1 = hitsEvt.idxs()[InnerMiniDoubletUpperHitIndex]; - unsigned int hit2 = hitsEvt.idxs()[OuterMiniDoubletLowerHitIndex]; - unsigned int hit3 = hitsEvt.idxs()[OuterMiniDoubletUpperHitIndex]; + unsigned int hit0 = hitsBase.idxs()[InnerMiniDoubletLowerHitIndex]; + unsigned int hit1 = hitsBase.idxs()[InnerMiniDoubletUpperHitIndex]; + unsigned int hit2 = hitsBase.idxs()[OuterMiniDoubletLowerHitIndex]; + unsigned int hit3 = hitsBase.idxs()[OuterMiniDoubletUpperHitIndex]; std::cout << "VALIDATION 'pLS': " << "pLS" << " hit0: " << hit0 << " hit1: " << hit1 << " hit2: " << hit2 << " hit3: " << hit3 << std::endl; @@ -1450,7 +1452,7 @@ void printT3s(LSTEvent* event) { auto const tripletsOccupancy = event->getTriplets(); SegmentsConst segments = event->getSegments(); MiniDoubletsConst miniDoublets = event->getMiniDoublets(); - auto hitsEvt = event->getHits(); + auto hitsBase = event->getInput(); auto modules = event->getModules(); int nTriplets = 0; for (unsigned int i = 0; i < modules.nLowerModules(); ++i) { @@ -1472,12 +1474,12 @@ void printT3s(LSTEvent* event) { unsigned int hit_idx4 = miniDoublets.anchorHitIndices()[OuterSegmentOuterMiniDoubletIndex]; unsigned int hit_idx5 = miniDoublets.outerHitIndices()[OuterSegmentOuterMiniDoubletIndex]; - unsigned int hit0 = hitsEvt.idxs()[hit_idx0]; - unsigned int hit1 = hitsEvt.idxs()[hit_idx1]; - unsigned int hit2 = hitsEvt.idxs()[hit_idx2]; - unsigned int hit3 = hitsEvt.idxs()[hit_idx3]; - unsigned int hit4 = hitsEvt.idxs()[hit_idx4]; - unsigned int hit5 = hitsEvt.idxs()[hit_idx5]; + unsigned int hit0 = hitsBase.idxs()[hit_idx0]; + unsigned int hit1 = hitsBase.idxs()[hit_idx1]; + unsigned int hit2 = hitsBase.idxs()[hit_idx2]; + unsigned int hit3 = hitsBase.idxs()[hit_idx3]; + unsigned int hit4 = hitsBase.idxs()[hit_idx4]; + unsigned int hit5 = hitsBase.idxs()[hit_idx5]; std::cout << "VALIDATION 'T3': " << "T3" << " hit0: " << hit0 << " hit1: " << hit1 << " hit2: " << hit2 << " hit3: " << hit3 << " hit4: " << hit4 diff --git a/Validation/RecoTrack/plugins/MultiTrackValidator.cc b/Validation/RecoTrack/plugins/MultiTrackValidator.cc index d49431f4cd4be..cee86fd21f379 100644 --- a/Validation/RecoTrack/plugins/MultiTrackValidator.cc +++ b/Validation/RecoTrack/plugins/MultiTrackValidator.cc @@ -1,5 +1,4 @@ #include "Validation/RecoTrack/interface/MultiTrackValidator.h" -#include "Validation/RecoTrack/interface/trackFromSeedFitFailed.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" @@ -7,6 +6,7 @@ #include "DataFormats/TrackReco/interface/Track.h" #include "DataFormats/TrackReco/interface/TrackFwd.h" +#include "DataFormats/TrackReco/interface/trackFromSeedFitFailed.h" #include "DataFormats/GsfTrackReco/interface/GsfTrack.h" #include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h" #include "SimDataFormats/Track/interface/SimTrackContainer.h" diff --git a/Validation/RecoTrack/plugins/TrackFromSeedProducer.cc b/Validation/RecoTrack/plugins/TrackFromSeedProducer.cc index c91cf15c5d148..cf08cabcd53ea 100644 --- a/Validation/RecoTrack/plugins/TrackFromSeedProducer.cc +++ b/Validation/RecoTrack/plugins/TrackFromSeedProducer.cc @@ -149,7 +149,7 @@ void TrackFromSeedProducer::produce(edm::StreamID, edm::Event& iEvent, const edm } else { edm::LogVerbatim("SeedValidator") << "TrajectoryStateClosestToBeamLine not valid"; // use magic values chi2<0, ndof<0, charge=0 to denote a case where the fit has failed - // If this definition is changed, change also interface/trackFromSeedFitFailed.h + // If this definition is changed, change also DataFormats/TrackReco/interface/trackFromSeedFitFailed.h tracks->emplace_back( -1, -1, reco::TrackBase::Point(), reco::TrackBase::Vector(), 0, reco::TrackBase::CovarianceMatrix()); nfailed++; diff --git a/Validation/RecoTrack/plugins/TrackingNtuple.cc b/Validation/RecoTrack/plugins/TrackingNtuple.cc index 0914bbc1fdb4c..a29681f8ba2cd 100644 --- a/Validation/RecoTrack/plugins/TrackingNtuple.cc +++ b/Validation/RecoTrack/plugins/TrackingNtuple.cc @@ -89,7 +89,7 @@ #include "SimTracker/TrackHistory/interface/HistoryBase.h" #include "HepPDT/ParticleID.hh" -#include "Validation/RecoTrack/interface/trackFromSeedFitFailed.h" +#include "DataFormats/TrackReco/interface/trackFromSeedFitFailed.h" #include "RecoTracker/FinalTrackSelectors/interface/getBestVertex.h" diff --git a/Validation/RecoTrack/src/MTVHistoProducerAlgoForTracker.cc b/Validation/RecoTrack/src/MTVHistoProducerAlgoForTracker.cc index 709df082d2e2e..8382ea9536128 100644 --- a/Validation/RecoTrack/src/MTVHistoProducerAlgoForTracker.cc +++ b/Validation/RecoTrack/src/MTVHistoProducerAlgoForTracker.cc @@ -1,8 +1,8 @@ #include "Validation/RecoTrack/interface/MTVHistoProducerAlgoForTracker.h" -#include "Validation/RecoTrack/interface/trackFromSeedFitFailed.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "DataFormats/TrackReco/interface/DeDxData.h" +#include "DataFormats/TrackReco/interface/trackFromSeedFitFailed.h" #include "DataFormats/Common/interface/ValueMap.h" #include "DataFormats/Common/interface/Ref.h" #include "DataFormats/TrackReco/interface/TrackFwd.h"