EcalRecProducers/plugins/EcalRecHitProducerGPU.cc

0001 #include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
0002 #include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
0003 #include "CommonTools/Utils/interface/StringToEnumValue.h"
0004 #include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
0005 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
0006 #include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
0007 #include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRcd.h"
0008 #include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRefRcd.h"
0009 #include "CondFormats/DataRecord/interface/EcalLaserAlphasRcd.h"
0010 #include "CondFormats/DataRecord/interface/EcalLinearCorrectionsRcd.h"
0011 #include "CondFormats/EcalObjects/interface/EcalIntercalibConstantsGPU.h"
0012 #include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosGPU.h"
0013 #include "CondFormats/EcalObjects/interface/EcalLaserAPDPNRatiosRefGPU.h"
0014 #include "CondFormats/EcalObjects/interface/EcalLaserAlphasGPU.h"
0015 #include "CondFormats/EcalObjects/interface/EcalLinearCorrectionsGPU.h"
0016 #include "CondFormats/EcalObjects/interface/EcalRecHitParametersGPU.h"
0017 #include "CondFormats/EcalObjects/interface/EcalRechitADCToGeVConstantGPU.h"
0018 #include "CondFormats/EcalObjects/interface/EcalRechitChannelStatusGPU.h"
0019 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
0020 #include "DataFormats/EcalRecHit/interface/RecoTypes.h"
0021 #include "FWCore/Framework/interface/Event.h"
0022 #include "FWCore/Framework/interface/EventSetup.h"
0023 #include "FWCore/Framework/interface/MakerMacros.h"
0024 #include "FWCore/Framework/interface/stream/EDProducer.h"
0025 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0026 #include "FWCore/ServiceRegistry/interface/Service.h"
0027 #include "FWCore/Utilities/interface/ESGetToken.h"
0028 #include "HeterogeneousCore/CUDACore/interface/JobConfigurationGPURecord.h"
0029 #include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
0030 #include "HeterogeneousCore/CUDAServices/interface/CUDAInterface.h"
0031 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
0032
0033 #include "EcalRecHitBuilderKernels.h"
0034
0035 class EcalRecHitProducerGPU : public edm::stream::EDProducer<edm::ExternalWork> {
0036 public:
0037   explicit EcalRecHitProducerGPU(edm::ParameterSet const& ps);
0038   ~EcalRecHitProducerGPU() override;
0039   static void fillDescriptions(edm::ConfigurationDescriptions&);
0040
0041 private:
0042   void acquire(edm::Event const&, edm::EventSetup const&, edm::WaitingTaskWithArenaHolder) override;
0043   void produce(edm::Event&, edm::EventSetup const&) override;
0044
0045 private:
0046   // data
0047   uint32_t neb_, nee_;  // extremely important, in particular neb_
0048
0049   // gpu input
0050   using InputProduct = cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>;
0051   edm::EDGetTokenT<InputProduct> uncalibRecHitsInEBToken_;
0052   edm::EDGetTokenT<InputProduct> uncalibRecHitsInEEToken_;
0053
0054   // event data
0055   ecal::rechit::EventOutputDataGPU eventOutputDataGPU_;
0056
0057   cms::cuda::ContextState cudaState_;
0058
0059   // gpu output
0060   using OutputProduct = cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>;
0061   edm::EDPutTokenT<OutputProduct> recHitsTokenEB_, recHitsTokenEE_;
0062
0063   // configuration parameters
0064   ecal::rechit::ConfigurationParameters configParameters_;
0065
0066   // conditions tokens
0067   edm::ESGetToken<EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstantRcd> tokenADCToGeVConstant_;
0068   edm::ESGetToken<EcalIntercalibConstantsGPU, EcalIntercalibConstantsRcd> tokenIntercalibConstants_;
0069   edm::ESGetToken<EcalRechitChannelStatusGPU, EcalChannelStatusRcd> tokenChannelStatus_;
0070   edm::ESGetToken<EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatiosRcd> tokenLaserAPDPNRatios_;
0071   edm::ESGetToken<EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRefRcd> tokenLaserAPDPNRatiosRef_;
0072   edm::ESGetToken<EcalLaserAlphasGPU, EcalLaserAlphasRcd> tokenLaserAlphas_;
0073   edm::ESGetToken<EcalLinearCorrectionsGPU, EcalLinearCorrectionsRcd> tokenLinearCorrections_;
0074   edm::ESGetToken<EcalRecHitParametersGPU, JobConfigurationGPURecord> tokenRecHitParameters_;
0075
0076   // conditions handles
0077   edm::ESHandle<EcalIntercalibConstantsGPU> IntercalibConstantsHandle_;
0078   edm::ESHandle<EcalRecHitParametersGPU> recHitParametersHandle_;
0079
0080   // Associate reco flagbit (outer vector) to many db status flags (inner vector)
0081   std::vector<int>
0082       expanded_v_DB_reco_flags_;  // Transform a map in a vector      // FIXME AM: int or uint32 to be checked
0083   std::vector<uint32_t> expanded_Sizes_v_DB_reco_flags_;    // Saving the size for each piece
0084   std::vector<uint32_t> expanded_flagbit_v_DB_reco_flags_;  // And the "key" for each key
0085
0086   uint32_t flagmask_;  // do not propagate channels with these flags on
0087 };
0088
0089 void EcalRecHitProducerGPU::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
0090   edm::ParameterSetDescription desc;
0091
0092   desc.add<edm::InputTag>("uncalibrecHitsInLabelEB",
0093                           edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEB"));
0094   desc.add<edm::InputTag>("uncalibrecHitsInLabelEE",
0095                           edm::InputTag("ecalUncalibRecHitProducerGPU", "EcalUncalibRecHitsEE"));
0096
0097   desc.add<std::string>("recHitsLabelEB", "EcalRecHitsGPUEB");
0098   desc.add<std::string>("recHitsLabelEE", "EcalRecHitsGPUEE");
0099
0100   desc.add<bool>("killDeadChannels", true);
0101
0102   desc.add<double>("EBLaserMIN", 0.01);
0103   desc.add<double>("EELaserMIN", 0.01);
0104   desc.add<double>("EBLaserMAX", 30.0);
0105   desc.add<double>("EELaserMAX", 30.0);
0106 }
0107
0108 EcalRecHitProducerGPU::EcalRecHitProducerGPU(const edm::ParameterSet& ps) {
0109   //---- input
0110   uncalibRecHitsInEBToken_ = consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEB"));
0111   uncalibRecHitsInEEToken_ = consumes<InputProduct>(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEE"));
0112
0113   //---- output
0114   recHitsTokenEB_ = produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEB"));
0115   recHitsTokenEE_ = produces<OutputProduct>(ps.getParameter<std::string>("recHitsLabelEE"));
0116
0117   bool killDeadChannels = ps.getParameter<bool>("killDeadChannels");
0118   configParameters_.killDeadChannels = killDeadChannels;
0119
0120   configParameters_.EBLaserMIN = ps.getParameter<double>("EBLaserMIN");
0121   configParameters_.EELaserMIN = ps.getParameter<double>("EELaserMIN");
0122   configParameters_.EBLaserMAX = ps.getParameter<double>("EBLaserMAX");
0123   configParameters_.EELaserMAX = ps.getParameter<double>("EELaserMAX");
0124
0125   flagmask_ = 0;
0126   flagmask_ |= 0x1 << EcalRecHit::kNeighboursRecovered;
0127   flagmask_ |= 0x1 << EcalRecHit::kTowerRecovered;
0128   flagmask_ |= 0x1 << EcalRecHit::kDead;
0129   flagmask_ |= 0x1 << EcalRecHit::kKilled;
0130   flagmask_ |= 0x1 << EcalRecHit::kTPSaturated;
0131   flagmask_ |= 0x1 << EcalRecHit::kL1SpikeFlag;
0132
0133   configParameters_.flagmask = flagmask_;
0134
0135   // for recovery and killing
0136
0137   configParameters_.recoverEBIsolatedChannels = ps.getParameter<bool>("recoverEBIsolatedChannels");
0138   configParameters_.recoverEEIsolatedChannels = ps.getParameter<bool>("recoverEEIsolatedChannels");
0139   configParameters_.recoverEBVFE = ps.getParameter<bool>("recoverEBVFE");
0140   configParameters_.recoverEEVFE = ps.getParameter<bool>("recoverEEVFE");
0141   configParameters_.recoverEBFE = ps.getParameter<bool>("recoverEBFE");
0142   configParameters_.recoverEEFE = ps.getParameter<bool>("recoverEEFE");
0143
0144   // conditions tokens
0145   tokenADCToGeVConstant_ = esConsumes<EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstantRcd>();
0146   tokenIntercalibConstants_ = esConsumes<EcalIntercalibConstantsGPU, EcalIntercalibConstantsRcd>();
0147   tokenChannelStatus_ = esConsumes<EcalRechitChannelStatusGPU, EcalChannelStatusRcd>();
0148   tokenLaserAPDPNRatios_ = esConsumes<EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatiosRcd>();
0149   tokenLaserAPDPNRatiosRef_ = esConsumes<EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRefRcd>();
0150   tokenLaserAlphas_ = esConsumes<EcalLaserAlphasGPU, EcalLaserAlphasRcd>();
0151   tokenLinearCorrections_ = esConsumes<EcalLinearCorrectionsGPU, EcalLinearCorrectionsRcd>();
0152   tokenRecHitParameters_ = esConsumes<EcalRecHitParametersGPU, JobConfigurationGPURecord>();
0153 }
0154
0155 EcalRecHitProducerGPU::~EcalRecHitProducerGPU() {}
0156
0157 void EcalRecHitProducerGPU::acquire(edm::Event const& event,
0158                                     edm::EventSetup const& setup,
0159                                     edm::WaitingTaskWithArenaHolder holder) {
0160   // cuda products
0161   auto const& ebUncalibRecHitsProduct = event.get(uncalibRecHitsInEBToken_);
0162   auto const& eeUncalibRecHitsProduct = event.get(uncalibRecHitsInEEToken_);
0163   // raii
0164   cms::cuda::ScopedContextAcquire ctx{ebUncalibRecHitsProduct, std::move(holder), cudaState_};
0165   // get actual object
0166   auto const& ebUncalibRecHits = ctx.get(ebUncalibRecHitsProduct);
0167   auto const& eeUncalibRecHits = ctx.get(eeUncalibRecHitsProduct);
0168
0169   ecal::rechit::EventInputDataGPU inputDataGPU{ebUncalibRecHits, eeUncalibRecHits};
0170
0171   neb_ = ebUncalibRecHits.size;
0172   nee_ = eeUncalibRecHits.size;
0173
0174   // stop here if there are no uncalibRecHits
0175   if (neb_ + nee_ == 0)
0176     return;
0177
0178   int nchannelsEB = ebUncalibRecHits.size;  // --> offsetForInput, first EB and then EE
0179
0180   // conditions
0181   // - laser correction
0182   // - IC
0183   // - adt2gev
0184
0185   //
0186   IntercalibConstantsHandle_ = setup.getHandle(tokenIntercalibConstants_);
0187   recHitParametersHandle_ = setup.getHandle(tokenRecHitParameters_);
0188
0189   auto const& ADCToGeVConstantProduct = setup.getData(tokenADCToGeVConstant_).getProduct(ctx.stream());
0190   auto const& IntercalibConstantsProduct = IntercalibConstantsHandle_->getProduct(ctx.stream());
0191   auto const& ChannelStatusProduct = setup.getData(tokenChannelStatus_).getProduct(ctx.stream());
0192
0193   auto const& LaserAPDPNRatiosProduct = setup.getData(tokenLaserAPDPNRatios_).getProduct(ctx.stream());
0194   auto const& LaserAPDPNRatiosRefProduct = setup.getData(tokenLaserAPDPNRatiosRef_).getProduct(ctx.stream());
0195   auto const& LaserAlphasProduct = setup.getData(tokenLaserAlphas_).getProduct(ctx.stream());
0196   auto const& LinearCorrectionsProduct = setup.getData(tokenLinearCorrections_).getProduct(ctx.stream());
0197   auto const& recHitParametersProduct = recHitParametersHandle_->getProduct(ctx.stream());
0198
0199   // set config ptrs : this is done to avoid changing things downstream
0200   configParameters_.ChannelStatusToBeExcluded = recHitParametersProduct.channelStatusToBeExcluded.get();
0201   configParameters_.ChannelStatusToBeExcludedSize = std::get<0>(recHitParametersHandle_->getValues()).get().size();
0202   configParameters_.expanded_v_DB_reco_flags = recHitParametersProduct.expanded_v_DB_reco_flags.get();
0203   configParameters_.expanded_Sizes_v_DB_reco_flags = recHitParametersProduct.expanded_Sizes_v_DB_reco_flags.get();
0204   configParameters_.expanded_flagbit_v_DB_reco_flags = recHitParametersProduct.expanded_flagbit_v_DB_reco_flags.get();
0205   configParameters_.expanded_v_DB_reco_flagsSize = std::get<3>(recHitParametersHandle_->getValues()).get().size();
0206
0207   // bundle up conditions
0208   ecal::rechit::ConditionsProducts conditions{ADCToGeVConstantProduct,
0209                                               IntercalibConstantsProduct,
0210                                               ChannelStatusProduct,
0211                                               LaserAPDPNRatiosProduct,
0212                                               LaserAPDPNRatiosRefProduct,
0213                                               LaserAlphasProduct,
0214                                               LinearCorrectionsProduct,
0215                                               IntercalibConstantsHandle_->getOffset()};
0216
0217   // dev mem
0218   eventOutputDataGPU_.allocate(configParameters_, neb_, nee_, ctx.stream());
0219
0220   //
0221   // schedule algorithms
0222   //
0223
0224   edm::TimeValue_t event_time = event.time().value();
0225
0226   ecal::rechit::create_ecal_rehit(
0227       inputDataGPU, eventOutputDataGPU_, conditions, configParameters_, nchannelsEB, event_time, ctx.stream());
0228
0229   cudaCheck(cudaGetLastError());
0230 }
0231
0232 void EcalRecHitProducerGPU::produce(edm::Event& event, edm::EventSetup const& setup) {
0233   cms::cuda::ScopedContextProduce ctx{cudaState_};
0234
0235   eventOutputDataGPU_.recHitsEB.size = neb_;
0236   eventOutputDataGPU_.recHitsEE.size = nee_;
0237
0238   // put into the event
0239   ctx.emplace(event, recHitsTokenEB_, std::move(eventOutputDataGPU_.recHitsEB));
0240   ctx.emplace(event, recHitsTokenEE_, std::move(eventOutputDataGPU_.recHitsEE));
0241 }
0242
0243 DEFINE_FWK_MODULE(EcalRecHitProducerGPU);