File indexing completed on 2024-04-06 12:25:54
0001 #include <iostream>
0002 #include <string>
0003
0004 #include "FWCore/Framework/interface/stream/EDProducer.h"
0005 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0006 #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h"
0007 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0008 #include "FWCore/Utilities/interface/EDGetToken.h"
0009 #include "FWCore/Utilities/interface/EDPutToken.h"
0010 #include "FWCore/Utilities/interface/InputTag.h"
0011
0012 #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
0013
0014 #include "HeterogeneousCore/CUDACore/interface/ScopedContext.h"
0015 #include "HeterogeneousCore/CUDACore/interface/ContextState.h"
0016 #include "HeterogeneousCore/CUDAUtilities/interface/cudaCheck.h"
0017 #include "HeterogeneousCore/CUDAUtilities/interface/MessageLogger.h"
0018
0019 #include "RecoLocalCalo/HGCalRecProducers/plugins/KernelManagerHGCalRecHit.h"
0020 #include "CUDADataFormats/HGCal/interface/HGCRecHitGPUProduct.h"
0021 #include "CUDADataFormats/HGCal/interface/HGCUncalibRecHitDevice.h"
0022 #include "CUDADataFormats/HGCal/interface/HGCUncalibRecHitHost.h"
0023
0024 class HEFRecHitGPU : public edm::stream::EDProducer<> {
0025 public:
0026 explicit HEFRecHitGPU(const edm::ParameterSet &ps);
0027 ~HEFRecHitGPU() override;
0028
0029 void produce(edm::Event &, const edm::EventSetup &) override;
0030
0031 private:
0032 edm::EDGetTokenT<HGChefUncalibratedRecHitCollection> uncalibRecHitCPUToken_;
0033 edm::EDPutTokenT<cms::cuda::Product<HGCRecHitGPUProduct>> recHitGPUToken_;
0034
0035 std::unique_ptr<HGChefRecHitCollection> rechits_;
0036
0037
0038 HGChefUncalibRecHitConstantData cdata_;
0039 HGCConstantVectorData vdata_;
0040
0041
0042 std::string assert_error_message_(std::string, const size_t &, const size_t &);
0043 void assert_sizes_constants_(const HGCConstantVectorData &);
0044
0045
0046 std::unique_ptr<hgcal::RecHitTools> tools_;
0047
0048
0049 void convert_collection_data_to_soa_(const uint32_t &, const HGChefUncalibratedRecHitCollection &);
0050 void convert_constant_data_(KernelConstantData<HGChefUncalibRecHitConstantData> *);
0051
0052 HGCRecHitGPUProduct prod_;
0053 HGCUncalibRecHitDevice d_uncalib_;
0054 HGCUncalibRecHitHost<HGChefUncalibratedRecHitCollection> h_uncalib_;
0055
0056 KernelConstantData<HGChefUncalibRecHitConstantData> *kcdata_;
0057 };
0058
0059 HEFRecHitGPU::HEFRecHitGPU(const edm::ParameterSet &ps)
0060 : uncalibRecHitCPUToken_{consumes<HGCUncalibratedRecHitCollection>(
0061 ps.getParameter<edm::InputTag>("HGCHEFUncalibRecHitsTok"))},
0062 recHitGPUToken_{produces<cms::cuda::Product<HGCRecHitGPUProduct>>()} {
0063 cdata_.keV2DIGI_ = ps.getParameter<double>("HGCHEF_keV2DIGI");
0064 cdata_.xmin_ = ps.getParameter<double>("minValSiPar");
0065 cdata_.xmax_ = ps.getParameter<double>("maxValSiPar");
0066 cdata_.aterm_ = ps.getParameter<double>("noiseSiPar");
0067 cdata_.cterm_ = ps.getParameter<double>("constSiPar");
0068 vdata_.fCPerMIP_ = ps.getParameter<std::vector<double>>("HGCHEF_fCPerMIP");
0069 vdata_.cce_ = ps.getParameter<edm::ParameterSet>("HGCHEF_cce").getParameter<std::vector<double>>("values");
0070 vdata_.noise_fC_ = ps.getParameter<edm::ParameterSet>("HGCHEF_noise_fC").getParameter<std::vector<double>>("values");
0071 vdata_.rcorr_ = ps.getParameter<std::vector<double>>("rcorr");
0072 vdata_.weights_ = ps.getParameter<std::vector<double>>("weights");
0073 cdata_.uncalib2GeV_ = 1e-6 / cdata_.keV2DIGI_;
0074 cdata_.layerOffset_ = 28;
0075 assert_sizes_constants_(vdata_);
0076
0077 kcdata_ = new KernelConstantData<HGChefUncalibRecHitConstantData>(cdata_, vdata_);
0078 convert_constant_data_(kcdata_);
0079
0080 tools_ = std::make_unique<hgcal::RecHitTools>();
0081 }
0082
0083 HEFRecHitGPU::~HEFRecHitGPU() { delete kcdata_; }
0084
0085 std::string HEFRecHitGPU::assert_error_message_(std::string var, const size_t &s1, const size_t &s2) {
0086 std::string str1 = "The '";
0087 std::string str2 = "' array must be of size ";
0088 std::string str3 = " to hold the configuration data, but is of size ";
0089 return str1 + var + str2 + std::to_string(s1) + str3 + std::to_string(s2);
0090 }
0091
0092 void HEFRecHitGPU::assert_sizes_constants_(const HGCConstantVectorData &vd) {
0093 if (vdata_.fCPerMIP_.size() != HGChefUncalibRecHitConstantData::hef_fCPerMIP)
0094 edm::LogError("WrongSize") << this->assert_error_message_(
0095 "fCPerMIP", HGChefUncalibRecHitConstantData::hef_fCPerMIP, vdata_.fCPerMIP_.size());
0096 else if (vdata_.cce_.size() != HGChefUncalibRecHitConstantData::hef_cce)
0097 edm::LogError("WrongSize") << this->assert_error_message_(
0098 "cce", HGChefUncalibRecHitConstantData::hef_cce, vdata_.cce_.size());
0099 else if (vdata_.noise_fC_.size() != HGChefUncalibRecHitConstantData::hef_noise_fC)
0100 edm::LogError("WrongSize") << this->assert_error_message_(
0101 "noise_fC", HGChefUncalibRecHitConstantData::hef_noise_fC, vdata_.noise_fC_.size());
0102 else if (vdata_.rcorr_.size() != HGChefUncalibRecHitConstantData::hef_rcorr)
0103 edm::LogError("WrongSize") << this->assert_error_message_(
0104 "rcorr", HGChefUncalibRecHitConstantData::hef_rcorr, vdata_.rcorr_.size());
0105 else if (vdata_.weights_.size() != HGChefUncalibRecHitConstantData::hef_weights)
0106 edm::LogError("WrongSize") << this->assert_error_message_(
0107 "weights", HGChefUncalibRecHitConstantData::hef_weights, vdata_.weights_.size());
0108 }
0109
0110 void HEFRecHitGPU::produce(edm::Event &event, const edm::EventSetup &setup) {
0111 cms::cuda::ScopedContextProduce ctx{event.streamID()};
0112
0113 const auto &hits = event.get(uncalibRecHitCPUToken_);
0114 unsigned int nhits(hits.size());
0115 rechits_ = std::make_unique<HGCRecHitCollection>();
0116
0117 if (nhits == 0)
0118 edm::LogError("HEFRecHitGPU") << "WARNING: no input hits!";
0119
0120 prod_ = HGCRecHitGPUProduct(nhits, ctx.stream());
0121 d_uncalib_ = HGCUncalibRecHitDevice(nhits, ctx.stream());
0122 h_uncalib_ = HGCUncalibRecHitHost<HGChefUncalibratedRecHitCollection>(nhits, hits, ctx.stream());
0123
0124 KernelManagerHGCalRecHit km(h_uncalib_.get(), d_uncalib_.get(), prod_.get());
0125 km.run_kernels(kcdata_, ctx.stream());
0126
0127 ctx.emplace(event, recHitGPUToken_, std::move(prod_));
0128 }
0129
0130 void HEFRecHitGPU::convert_constant_data_(KernelConstantData<HGChefUncalibRecHitConstantData> *kcdata) {
0131 for (size_t i = 0; i < kcdata->vdata_.fCPerMIP_.size(); ++i)
0132 kcdata->data_.fCPerMIP_[i] = kcdata->vdata_.fCPerMIP_[i];
0133 for (size_t i = 0; i < kcdata->vdata_.cce_.size(); ++i)
0134 kcdata->data_.cce_[i] = kcdata->vdata_.cce_[i];
0135 for (size_t i = 0; i < kcdata->vdata_.noise_fC_.size(); ++i)
0136 kcdata->data_.noise_fC_[i] = kcdata->vdata_.noise_fC_[i];
0137 for (size_t i = 0; i < kcdata->vdata_.rcorr_.size(); ++i)
0138 kcdata->data_.rcorr_[i] = kcdata->vdata_.rcorr_[i];
0139 for (size_t i = 0; i < kcdata->vdata_.weights_.size(); ++i)
0140 kcdata->data_.weights_[i] = kcdata->vdata_.weights_[i];
0141 }
0142
0143 #include "FWCore/Framework/interface/MakerMacros.h"
0144 DEFINE_FWK_MODULE(HEFRecHitGPU);