plugins/alpaka/EcalUncalibRecHitProducerPortable.cc

0001 #include "CondFormats/DataRecord/interface/EcalMultifitConditionsRcd.h"
0002 #include "CondFormats/DataRecord/interface/EcalMultifitParametersRcd.h"
0003 #include "CondFormats/EcalObjects/interface/alpaka/EcalMultifitConditionsDevice.h"
0004 #include "CondFormats/EcalObjects/interface/alpaka/EcalMultifitParametersDevice.h"
0005 #include "DataFormats/EcalDigi/interface/alpaka/EcalDigiDeviceCollection.h"
0006 #include "DataFormats/EcalRecHit/interface/alpaka/EcalUncalibratedRecHitDeviceCollection.h"
0007 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0008 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0009 #include "FWCore/ParameterSet/interface/ParameterSetDescription.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 "EcalUncalibRecHitMultiFitAlgoPortable.h"
0018
0019 namespace ALPAKA_ACCELERATOR_NAMESPACE {
0020
0021   class EcalUncalibRecHitProducerPortable : public stream::SynchronizingEDProducer<> {
0022   public:
0023     explicit EcalUncalibRecHitProducerPortable(edm::ParameterSet const& ps);
0024     ~EcalUncalibRecHitProducerPortable() override = default;
0025     static void fillDescriptions(edm::ConfigurationDescriptions&);
0026
0027     void acquire(device::Event const&, device::EventSetup const&) override;
0028     void produce(device::Event&, device::EventSetup const&) override;
0029
0030   private:
0031     using InputProduct = EcalDigiDeviceCollection;
0032     const device::EDGetToken<InputProduct> digisTokenEB_;
0033     const device::EDGetToken<InputProduct> digisTokenEE_;
0034     using OutputProduct = EcalUncalibratedRecHitDeviceCollection;
0035     const device::EDPutToken<OutputProduct> uncalibRecHitsTokenEB_;
0036     const device::EDPutToken<OutputProduct> uncalibRecHitsTokenEE_;
0037
0038     // conditions tokens
0039     const device::ESGetToken<EcalMultifitConditionsDevice, EcalMultifitConditionsRcd> multifitConditionsToken_;
0040     const device::ESGetToken<EcalMultifitParametersDevice, EcalMultifitParametersRcd> multifitParametersToken_;
0041
0042     // configuration parameters
0043     ecal::multifit::ConfigurationParameters configParameters_;
0044
0045     cms::alpakatools::host_buffer<uint32_t> ebDigisSizeHostBuf_;
0046     cms::alpakatools::host_buffer<uint32_t> eeDigisSizeHostBuf_;
0047   };
0048
0049   void EcalUncalibRecHitProducerPortable::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
0050     edm::ParameterSetDescription desc;
0051
0052     desc.add<edm::InputTag>("digisLabelEB", edm::InputTag("ecalRawToDigiPortable", "ebDigis"));
0053     desc.add<edm::InputTag>("digisLabelEE", edm::InputTag("ecalRawToDigiPortable", "eeDigis"));
0054
0055     desc.add<std::string>("recHitsLabelEB", "EcalUncalibRecHitsEB");
0056     desc.add<std::string>("recHitsLabelEE", "EcalUncalibRecHitsEE");
0057
0058     desc.add<double>("EBtimeFitLimits_Lower", 0.2);
0059     desc.add<double>("EBtimeFitLimits_Upper", 1.4);
0060     desc.add<double>("EEtimeFitLimits_Lower", 0.2);
0061     desc.add<double>("EEtimeFitLimits_Upper", 1.4);
0062     desc.add<double>("EBtimeConstantTerm", .6);
0063     desc.add<double>("EEtimeConstantTerm", 1.0);
0064     desc.add<double>("EBtimeNconst", 28.5);
0065     desc.add<double>("EEtimeNconst", 31.8);
0066     desc.add<double>("outOfTimeThresholdGain12pEB", 5);
0067     desc.add<double>("outOfTimeThresholdGain12mEB", 5);
0068     desc.add<double>("outOfTimeThresholdGain61pEB", 5);
0069     desc.add<double>("outOfTimeThresholdGain61mEB", 5);
0070     desc.add<double>("outOfTimeThresholdGain12pEE", 1000);
0071     desc.add<double>("outOfTimeThresholdGain12mEE", 1000);
0072     desc.add<double>("outOfTimeThresholdGain61pEE", 1000);
0073     desc.add<double>("outOfTimeThresholdGain61mEE", 1000);
0074     desc.add<double>("amplitudeThresholdEB", 10);
0075     desc.add<double>("amplitudeThresholdEE", 10);
0076     desc.addUntracked<std::vector<uint32_t>>("kernelMinimizeThreads", {32, 1, 1});
0077     desc.add<bool>("shouldRunTimingComputation", true);
0078     confDesc.addWithDefaultLabel(desc);
0079   }
0080
0081   EcalUncalibRecHitProducerPortable::EcalUncalibRecHitProducerPortable(const edm::ParameterSet& ps)
0082       : digisTokenEB_{consumes(ps.getParameter<edm::InputTag>("digisLabelEB"))},
0083         digisTokenEE_{consumes(ps.getParameter<edm::InputTag>("digisLabelEE"))},
0084         uncalibRecHitsTokenEB_{produces(ps.getParameter<std::string>("recHitsLabelEB"))},
0085         uncalibRecHitsTokenEE_{produces(ps.getParameter<std::string>("recHitsLabelEE"))},
0086         multifitConditionsToken_{esConsumes()},
0087         multifitParametersToken_{esConsumes()},
0088         ebDigisSizeHostBuf_{cms::alpakatools::make_host_buffer<uint32_t>()},
0089         eeDigisSizeHostBuf_{cms::alpakatools::make_host_buffer<uint32_t>()} {
0090     std::pair<double, double> EBtimeFitLimits, EEtimeFitLimits;
0091     EBtimeFitLimits.first = ps.getParameter<double>("EBtimeFitLimits_Lower");
0092     EBtimeFitLimits.second = ps.getParameter<double>("EBtimeFitLimits_Upper");
0093     EEtimeFitLimits.first = ps.getParameter<double>("EEtimeFitLimits_Lower");
0094     EEtimeFitLimits.second = ps.getParameter<double>("EEtimeFitLimits_Upper");
0095
0096     auto EBtimeConstantTerm = ps.getParameter<double>("EBtimeConstantTerm");
0097     auto EEtimeConstantTerm = ps.getParameter<double>("EEtimeConstantTerm");
0098     auto EBtimeNconst = ps.getParameter<double>("EBtimeNconst");
0099     auto EEtimeNconst = ps.getParameter<double>("EEtimeNconst");
0100
0101     auto outOfTimeThreshG12pEB = ps.getParameter<double>("outOfTimeThresholdGain12pEB");
0102     auto outOfTimeThreshG12mEB = ps.getParameter<double>("outOfTimeThresholdGain12mEB");
0103     auto outOfTimeThreshG61pEB = ps.getParameter<double>("outOfTimeThresholdGain61pEB");
0104     auto outOfTimeThreshG61mEB = ps.getParameter<double>("outOfTimeThresholdGain61mEB");
0105     auto outOfTimeThreshG12pEE = ps.getParameter<double>("outOfTimeThresholdGain12pEE");
0106     auto outOfTimeThreshG12mEE = ps.getParameter<double>("outOfTimeThresholdGain12mEE");
0107     auto outOfTimeThreshG61pEE = ps.getParameter<double>("outOfTimeThresholdGain61pEE");
0108     auto outOfTimeThreshG61mEE = ps.getParameter<double>("outOfTimeThresholdGain61mEE");
0109     auto amplitudeThreshEB = ps.getParameter<double>("amplitudeThresholdEB");
0110     auto amplitudeThreshEE = ps.getParameter<double>("amplitudeThresholdEE");
0111
0112     // switch to run timing computation kernels
0113     configParameters_.shouldRunTimingComputation = ps.getParameter<bool>("shouldRunTimingComputation");
0114
0115     // minimize kernel launch conf
0116     auto threadsMinimize = ps.getUntrackedParameter<std::vector<uint32_t>>("kernelMinimizeThreads");
0117     configParameters_.kernelMinimizeThreads[0] = threadsMinimize[0];
0118     configParameters_.kernelMinimizeThreads[1] = threadsMinimize[1];
0119     configParameters_.kernelMinimizeThreads[2] = threadsMinimize[2];
0120
0121     //
0122     // configuration and physics parameters: done once
0123     // assume there is a single device
0124     // use sync copying
0125     //
0126
0127     // time fit parameters and limits
0128     configParameters_.timeFitLimitsFirstEB = EBtimeFitLimits.first;
0129     configParameters_.timeFitLimitsSecondEB = EBtimeFitLimits.second;
0130     configParameters_.timeFitLimitsFirstEE = EEtimeFitLimits.first;
0131     configParameters_.timeFitLimitsSecondEE = EEtimeFitLimits.second;
0132
0133     // time constant terms
0134     configParameters_.timeConstantTermEB = EBtimeConstantTerm;
0135     configParameters_.timeConstantTermEE = EEtimeConstantTerm;
0136
0137     // time N const
0138     configParameters_.timeNconstEB = EBtimeNconst;
0139     configParameters_.timeNconstEE = EEtimeNconst;
0140
0141     // amplitude threshold for time flags
0142     configParameters_.amplitudeThreshEB = amplitudeThreshEB;
0143     configParameters_.amplitudeThreshEE = amplitudeThreshEE;
0144
0145     // out of time thresholds gain-dependent
0146     configParameters_.outOfTimeThreshG12pEB = outOfTimeThreshG12pEB;
0147     configParameters_.outOfTimeThreshG12pEE = outOfTimeThreshG12pEE;
0148     configParameters_.outOfTimeThreshG61pEB = outOfTimeThreshG61pEB;
0149     configParameters_.outOfTimeThreshG61pEE = outOfTimeThreshG61pEE;
0150     configParameters_.outOfTimeThreshG12mEB = outOfTimeThreshG12mEB;
0151     configParameters_.outOfTimeThreshG12mEE = outOfTimeThreshG12mEE;
0152     configParameters_.outOfTimeThreshG61mEB = outOfTimeThreshG61mEB;
0153     configParameters_.outOfTimeThreshG61mEE = outOfTimeThreshG61mEE;
0154   }
0155
0156   void EcalUncalibRecHitProducerPortable::acquire(device::Event const& event, device::EventSetup const& setup) {
0157     auto& queue = event.queue();
0158
0159     // get device collections from event
0160     auto const& ebDigisDev = event.get(digisTokenEB_);
0161     auto const& eeDigisDev = event.get(digisTokenEE_);
0162
0163     // copy the actual numbers of digis in the collections to host
0164     auto ebDigisSizeDevConstView =
0165         cms::alpakatools::make_device_view<const uint32_t>(alpaka::getDev(queue), ebDigisDev.const_view().size());
0166     auto eeDigisSizeDevConstView =
0167         cms::alpakatools::make_device_view<const uint32_t>(alpaka::getDev(queue), eeDigisDev.const_view().size());
0168     alpaka::memcpy(queue, ebDigisSizeHostBuf_, ebDigisSizeDevConstView);
0169     alpaka::memcpy(queue, eeDigisSizeHostBuf_, eeDigisSizeDevConstView);
0170   }
0171
0172   void EcalUncalibRecHitProducerPortable::produce(device::Event& event, device::EventSetup const& setup) {
0173     auto& queue = event.queue();
0174
0175     // get device collections from event
0176     auto const& ebDigisDev = event.get(digisTokenEB_);
0177     auto const& eeDigisDev = event.get(digisTokenEE_);
0178
0179     // get the actual numbers of digis in the collections
0180     auto const ebDigisSize = static_cast<int>(*ebDigisSizeHostBuf_.data());
0181     auto const eeDigisSize = static_cast<int>(*eeDigisSizeHostBuf_.data());
0182
0183     // output device collections
0184     OutputProduct uncalibRecHitsDevEB{ebDigisSize, queue};
0185     OutputProduct uncalibRecHitsDevEE{eeDigisSize, queue};
0186     // reset the size scalar of the SoA
0187     // memset takes an alpaka view that is created from the scalar in a view to the portable device collection
0188     auto uncalibRecHitSizeViewEB =
0189         cms::alpakatools::make_device_view<uint32_t>(alpaka::getDev(queue), uncalibRecHitsDevEB.view().size());
0190     auto uncalibRecHitSizeViewEE =
0191         cms::alpakatools::make_device_view<uint32_t>(alpaka::getDev(queue), uncalibRecHitsDevEE.view().size());
0192     alpaka::memset(queue, uncalibRecHitSizeViewEB, 0);
0193     alpaka::memset(queue, uncalibRecHitSizeViewEE, 0);
0194
0195     // stop here if there are no digis
0196     if (ebDigisSize + eeDigisSize > 0) {
0197       // conditions
0198       auto const& multifitConditionsDev = setup.getData(multifitConditionsToken_);
0199       auto const& multifitParametersDev = setup.getData(multifitParametersToken_);
0200
0201       //
0202       // schedule algorithms
0203       //
0204       ecal::multifit::launchKernels(queue,
0205                                     ebDigisDev,
0206                                     eeDigisDev,
0207                                     uncalibRecHitsDevEB,
0208                                     uncalibRecHitsDevEE,
0209                                     multifitConditionsDev,
0210                                     multifitParametersDev,
0211                                     configParameters_);
0212     }
0213
0214     // put into the event
0215     event.emplace(uncalibRecHitsTokenEB_, std::move(uncalibRecHitsDevEB));
0216     event.emplace(uncalibRecHitsTokenEE_, std::move(uncalibRecHitsDevEE));
0217   }
0218
0219 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE
0220
0221 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/MakerMacros.h"
0222 DEFINE_FWK_ALPAKA_MODULE(EcalUncalibRecHitProducerPortable);