plugins/alpaka/EcalUncalibRecHitProducerPortable.cc

0001 #include "CondFormats/DataRecord/interface/EcalMultifitConditionsRcd.h"
0002 #include "CondFormats/EcalObjects/interface/alpaka/EcalMultifitConditionsDevice.h"
0003 #include "DataFormats/EcalDigi/interface/alpaka/EcalDigiDeviceCollection.h"
0004 #include "DataFormats/EcalRecHit/interface/alpaka/EcalUncalibratedRecHitDeviceCollection.h"
0005 #include "DataFormats/Portable/interface/PortableObject.h"
0006 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0007 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0009 #include "HeterogeneousCore/AlpakaCore/interface/MoveToDeviceCache.h"
0010 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDGetToken.h"
0011 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDPutToken.h"
0012 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/Event.h"
0013 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EventSetup.h"
0014 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/stream/SynchronizingEDProducer.h"
0015
0016 #include "DeclsForKernels.h"
0017 #include "EcalMultifitParameters.h"
0018 #include "EcalUncalibRecHitMultiFitAlgoPortable.h"
0019
0020 #include <algorithm>
0021
0022 namespace ALPAKA_ACCELERATOR_NAMESPACE {
0023   namespace {
0024     using EcalMultifitParametersCache =
0025         cms::alpakatools::MoveToDeviceCache<Device, PortableHostObject<EcalMultifitParameters>>;
0026   }
0027
0028   class EcalUncalibRecHitProducerPortable
0029       : public stream::SynchronizingEDProducer<edm::GlobalCache<EcalMultifitParametersCache>> {
0030   public:
0031     explicit EcalUncalibRecHitProducerPortable(edm::ParameterSet const& ps, EcalMultifitParametersCache const*);
0032     ~EcalUncalibRecHitProducerPortable() override = default;
0033     static void fillDescriptions(edm::ConfigurationDescriptions&);
0034     static std::unique_ptr<EcalMultifitParametersCache> initializeGlobalCache(edm::ParameterSet const& ps);
0035
0036     void acquire(device::Event const&, device::EventSetup const&) override;
0037     void produce(device::Event&, device::EventSetup const&) override;
0038
0039     static void globalEndJob(EcalMultifitParametersCache*) {}
0040
0041   private:
0042     using InputProduct = EcalDigiDeviceCollection;
0043     const device::EDGetToken<InputProduct> digisTokenEB_;
0044     const device::EDGetToken<InputProduct> digisTokenEE_;
0045     using OutputProduct = EcalUncalibratedRecHitDeviceCollection;
0046     const device::EDPutToken<OutputProduct> uncalibRecHitsTokenEB_;
0047     const device::EDPutToken<OutputProduct> uncalibRecHitsTokenEE_;
0048
0049     // conditions tokens
0050     const device::ESGetToken<EcalMultifitConditionsDevice, EcalMultifitConditionsRcd> multifitConditionsToken_;
0051
0052     // configuration parameters
0053     ecal::multifit::ConfigurationParameters configParameters_;
0054
0055     cms::alpakatools::host_buffer<uint32_t> ebDigisSizeHostBuf_;
0056     cms::alpakatools::host_buffer<uint32_t> eeDigisSizeHostBuf_;
0057   };
0058
0059   void EcalUncalibRecHitProducerPortable::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
0060     edm::ParameterSetDescription desc;
0061
0062     desc.add<edm::InputTag>("digisLabelEB", edm::InputTag("ecalRawToDigiPortable", "ebDigis"));
0063     desc.add<edm::InputTag>("digisLabelEE", edm::InputTag("ecalRawToDigiPortable", "eeDigis"));
0064
0065     desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
0066     desc.add<std::string>("recHitsLabelEE", "EcalUncalibRecHitsEE");
0067
0068     desc.add<double>("EBtimeFitLimits_Lower", 0.2);
0069     desc.add<double>("EBtimeFitLimits_Upper", 1.4);
0070     desc.add<double>("EEtimeFitLimits_Lower", 0.2);
0071     desc.add<double>("EEtimeFitLimits_Upper", 1.4);
0072     desc.add<double>("EBtimeConstantTerm", .6);
0073     desc.add<double>("EEtimeConstantTerm", 1.0);
0074     desc.add<double>("EBtimeNconst", 28.5);
0075     desc.add<double>("EEtimeNconst", 31.8);
0076     desc.add<double>("outOfTimeThresholdGain12pEB", 5);
0077     desc.add<double>("outOfTimeThresholdGain12mEB", 5);
0078     desc.add<double>("outOfTimeThresholdGain61pEB", 5);
0079     desc.add<double>("outOfTimeThresholdGain61mEB", 5);
0080     desc.add<double>("outOfTimeThresholdGain12pEE", 1000);
0081     desc.add<double>("outOfTimeThresholdGain12mEE", 1000);
0082     desc.add<double>("outOfTimeThresholdGain61pEE", 1000);
0083     desc.add<double>("outOfTimeThresholdGain61mEE", 1000);
0084     desc.add<double>("amplitudeThresholdEB", 10);
0085     desc.add<double>("amplitudeThresholdEE", 10);
0086
0087     desc.add<std::vector<double>>("EBtimeFitParameters",
0088                                   {-2.015452e+00,
0089                                    3.130702e+00,
0090                                    -1.234730e+01,
0091                                    4.188921e+01,
0092                                    -8.283944e+01,
0093                                    9.101147e+01,
0094                                    -5.035761e+01,
0095                                    1.105621e+01});
0096     desc.add<std::vector<double>>("EEtimeFitParameters",
0097                                   {-2.390548e+00,
0098                                    3.553628e+00,
0099                                    -1.762341e+01,
0100                                    6.767538e+01,
0101                                    -1.332130e+02,
0102                                    1.407432e+02,
0103                                    -7.541106e+01,
0104                                    1.620277e+01});
0105     desc.add<std::vector<double>>("EBamplitudeFitParameters", {1.138, 1.652});
0106     desc.add<std::vector<double>>("EEamplitudeFitParameters", {1.890, 1.400});
0107
0108     desc.addUntracked<std::vector<uint32_t>>("kernelMinimizeThreads", {32, 1, 1});
0109     desc.add<bool>("shouldRunTimingComputation", true);
0110
0111     confDesc.addWithDefaultLabel(desc);
0112   }
0113
0114   std::unique_ptr<EcalMultifitParametersCache> EcalUncalibRecHitProducerPortable::initializeGlobalCache(
0115       edm::ParameterSet const& ps) {
0116     PortableHostObject<EcalMultifitParameters> params(cms::alpakatools::host());
0117
0118     auto const ebTimeFitParamsFromPSet = ps.getParameter<std::vector<double>>("EBtimeFitParameters");
0119     auto const eeTimeFitParamsFromPSet = ps.getParameter<std::vector<double>>("EEtimeFitParameters");
0120     // Assert that there are as many parameters as the EcalMultiFitParametersSoA expects
0121     assert(ebTimeFitParamsFromPSet.size() == EcalMultifitParameters::kNTimeFitParams);
0122     assert(eeTimeFitParamsFromPSet.size() == EcalMultifitParameters::kNTimeFitParams);
0123     std::ranges::copy(ebTimeFitParamsFromPSet, params->timeFitParamsEB.begin());
0124     std::ranges::copy(eeTimeFitParamsFromPSet, params->timeFitParamsEE.begin());
0125
0126     std::vector<float> ebAmplitudeFitParameters_;
0127     std::vector<float> eeAmplitudeFitParameters_;
0128     auto const ebAmplFitParamsFromPSet = ps.getParameter<std::vector<double>>("EBamplitudeFitParameters");
0129     auto const eeAmplFitParamsFromPSet = ps.getParameter<std::vector<double>>("EEamplitudeFitParameters");
0130     // Assert that there are as many parameters as the EcalMultiFitParametersSoA expects
0131     assert(ebAmplFitParamsFromPSet.size() == EcalMultifitParameters::kNAmplitudeFitParams);
0132     assert(eeAmplFitParamsFromPSet.size() == EcalMultifitParameters::kNAmplitudeFitParams);
0133     std::ranges::copy(ebAmplFitParamsFromPSet, params->amplitudeFitParamsEB.begin());
0134     std::ranges::copy(eeAmplFitParamsFromPSet, params->amplitudeFitParamsEE.begin());
0135
0136     return std::make_unique<EcalMultifitParametersCache>(std::move(params));
0137   }
0138
0139   EcalUncalibRecHitProducerPortable::EcalUncalibRecHitProducerPortable(const edm::ParameterSet& ps,
0140                                                                        EcalMultifitParametersCache const*)
0141       : SynchronizingEDProducer(ps),
0142         digisTokenEB_{consumes(ps.getParameter<edm::InputTag>("digisLabelEB"))},
0143         digisTokenEE_{consumes(ps.getParameter<edm::InputTag>("digisLabelEE"))},
0144         uncalibRecHitsTokenEB_{produces(ps.getParameter<std::string>("recHitsLabelEB"))},
0145         uncalibRecHitsTokenEE_{produces(ps.getParameter<std::string>("recHitsLabelEE"))},
0146         multifitConditionsToken_{esConsumes()},
0147         ebDigisSizeHostBuf_{cms::alpakatools::make_host_buffer<uint32_t>()},
0148         eeDigisSizeHostBuf_{cms::alpakatools::make_host_buffer<uint32_t>()} {
0149     std::pair<double, double> EBtimeFitLimits, EEtimeFitLimits;
0150     EBtimeFitLimits.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
0151     EBtimeFitLimits.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
0152     EEtimeFitLimits.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
0153     EEtimeFitLimits.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
0154
0155     auto EBtimeConstantTerm = ps.getParameter<double>("EBtimeConstantTerm");
0156     auto EEtimeConstantTerm = ps.getParameter<double>("EEtimeConstantTerm");
0157     auto EBtimeNconst = ps.getParameter<double>("EBtimeNconst");
0158     auto EEtimeNconst = ps.getParameter<double>("EEtimeNconst");
0159
0160     auto outOfTimeThreshG12pEB = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
0161     auto outOfTimeThreshG12mEB = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
0162     auto outOfTimeThreshG61pEB = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
0163     auto outOfTimeThreshG61mEB = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
0164     auto outOfTimeThreshG12pEE = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
0165     auto outOfTimeThreshG12mEE = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
0166     auto outOfTimeThreshG61pEE = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
0167     auto outOfTimeThreshG61mEE = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
0168     auto amplitudeThreshEB = ps.getParameter<double>("amplitudeThresholdEB");
0169     auto amplitudeThreshEE = ps.getParameter<double>("amplitudeThresholdEE");
0170
0171     // switch to run timing computation kernels
0172     configParameters_.shouldRunTimingComputation = ps.getParameter<bool>("shouldRunTimingComputation");
0173
0174     // minimize kernel launch conf
0175     auto threadsMinimize = ps.getUntrackedParameter<std::vector<uint32_t>>("kernelMinimizeThreads");
0176     configParameters_.kernelMinimizeThreads[0] = threadsMinimize[0];
0177     configParameters_.kernelMinimizeThreads[1] = threadsMinimize[1];
0178     configParameters_.kernelMinimizeThreads[2] = threadsMinimize[2];
0179
0180     //
0181     // configuration and physics parameters: done once
0182     // assume there is a single device
0183     // use sync copying
0184     //
0185
0186     // time fit parameters and limits
0187     configParameters_.timeFitLimitsFirstEB = EBtimeFitLimits.first;
0188     configParameters_.timeFitLimitsSecondEB = EBtimeFitLimits.second;
0189     configParameters_.timeFitLimitsFirstEE = EEtimeFitLimits.first;
0190     configParameters_.timeFitLimitsSecondEE = EEtimeFitLimits.second;
0191
0192     // time constant terms
0193     configParameters_.timeConstantTermEB = EBtimeConstantTerm;
0194     configParameters_.timeConstantTermEE = EEtimeConstantTerm;
0195
0196     // time N const
0197     configParameters_.timeNconstEB = EBtimeNconst;
0198     configParameters_.timeNconstEE = EEtimeNconst;
0199
0200     // amplitude threshold for time flags
0201     configParameters_.amplitudeThreshEB = amplitudeThreshEB;
0202     configParameters_.amplitudeThreshEE = amplitudeThreshEE;
0203
0204     // out of time thresholds gain-dependent
0205     configParameters_.outOfTimeThreshG12pEB = outOfTimeThreshG12pEB;
0206     configParameters_.outOfTimeThreshG12pEE = outOfTimeThreshG12pEE;
0207     configParameters_.outOfTimeThreshG61pEB = outOfTimeThreshG61pEB;
0208     configParameters_.outOfTimeThreshG61pEE = outOfTimeThreshG61pEE;
0209     configParameters_.outOfTimeThreshG12mEB = outOfTimeThreshG12mEB;
0210     configParameters_.outOfTimeThreshG12mEE = outOfTimeThreshG12mEE;
0211     configParameters_.outOfTimeThreshG61mEB = outOfTimeThreshG61mEB;
0212     configParameters_.outOfTimeThreshG61mEE = outOfTimeThreshG61mEE;
0213   }
0214
0215   void EcalUncalibRecHitProducerPortable::acquire(device::Event const& event, device::EventSetup const& setup) {
0216     auto& queue = event.queue();
0217
0218     // get device collections from event
0219     auto const& ebDigisDev = event.get(digisTokenEB_);
0220     auto const& eeDigisDev = event.get(digisTokenEE_);
0221
0222     // copy the actual numbers of digis in the collections to host
0223     auto ebDigisSizeDevConstView =
0224         cms::alpakatools::make_device_view<const uint32_t>(queue, ebDigisDev.const_view().size());
0225     auto eeDigisSizeDevConstView =
0226         cms::alpakatools::make_device_view<const uint32_t>(queue, eeDigisDev.const_view().size());
0227     alpaka::memcpy(queue, ebDigisSizeHostBuf_, ebDigisSizeDevConstView);
0228     alpaka::memcpy(queue, eeDigisSizeHostBuf_, eeDigisSizeDevConstView);
0229   }
0230
0231   void EcalUncalibRecHitProducerPortable::produce(device::Event& event, device::EventSetup const& setup) {
0232     auto& queue = event.queue();
0233
0234     // get device collections from event
0235     auto const& ebDigisDev = event.get(digisTokenEB_);
0236     auto const& eeDigisDev = event.get(digisTokenEE_);
0237
0238     // get the actual numbers of digis in the collections
0239     auto const ebDigisSize = static_cast<int>(*ebDigisSizeHostBuf_.data());
0240     auto const eeDigisSize = static_cast<int>(*eeDigisSizeHostBuf_.data());
0241
0242     // output device collections
0243     OutputProduct uncalibRecHitsDevEB{ebDigisSize, queue};
0244     OutputProduct uncalibRecHitsDevEE{eeDigisSize, queue};
0245     // reset the size scalar of the SoA
0246     // memset takes an alpaka view that is created from the scalar in a view to the portable device collection
0247     auto uncalibRecHitSizeViewEB =
0248         cms::alpakatools::make_device_view<uint32_t>(queue, uncalibRecHitsDevEB.view().size());
0249     auto uncalibRecHitSizeViewEE =
0250         cms::alpakatools::make_device_view<uint32_t>(queue, uncalibRecHitsDevEE.view().size());
0251     alpaka::memset(queue, uncalibRecHitSizeViewEB, 0);
0252     alpaka::memset(queue, uncalibRecHitSizeViewEE, 0);
0253
0254     // stop here if there are no digis
0255     if (ebDigisSize + eeDigisSize > 0) {
0256       // conditions
0257       auto const& multifitConditionsDev = setup.getData(multifitConditionsToken_);
0258       auto const* multifitParametersDev = globalCache()->get(queue).const_data();
0259
0260       //
0261       // schedule algorithms
0262       //
0263       ecal::multifit::launchKernels(queue,
0264                                     ebDigisDev,
0265                                     eeDigisDev,
0266                                     uncalibRecHitsDevEB,
0267                                     uncalibRecHitsDevEE,
0268                                     multifitConditionsDev,
0269                                     multifitParametersDev,
0270                                     configParameters_);
0271     }
0272
0273     // put into the event
0274     event.emplace(uncalibRecHitsTokenEB_, std::move(uncalibRecHitsDevEB));
0275     event.emplace(uncalibRecHitsTokenEE_, std::move(uncalibRecHitsDevEE));
0276   }
0277
0278 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE
0279
0280 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/MakerMacros.h"
0281 DEFINE_FWK_ALPAKA_MODULE(EcalUncalibRecHitProducerPortable);