Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-02-05 03:15:13

0001 #include "CommonTools/Utils/interface/StringToEnumValue.h"
0002 #include "CondFormats/DataRecord/interface/EcalRecHitConditionsRcd.h"
0003 #include "CondFormats/EcalObjects/interface/EcalChannelStatusCode.h"
0004 #include "CondFormats/EcalObjects/interface/EcalRecHitParameters.h"
0005 #include "CondFormats/EcalObjects/interface/alpaka/EcalRecHitConditionsDevice.h"
0006 #include "DataFormats/EcalRecHit/interface/EcalRecHit.h"
0007 #include "DataFormats/EcalRecHit/interface/RecoTypes.h"
0008 #include "DataFormats/EcalRecHit/interface/alpaka/EcalUncalibratedRecHitDeviceCollection.h"
0009 #include "DataFormats/EcalRecHit/interface/alpaka/EcalRecHitDeviceCollection.h"
0010 #include "DataFormats/Portable/interface/PortableObject.h"
0011 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0012 #include "FWCore/ParameterSet/interface/EmptyGroupDescription.h"
0013 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0014 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0015 #include "HeterogeneousCore/AlpakaCore/interface/MoveToDeviceCache.h"
0016 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDGetToken.h"
0017 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EDPutToken.h"
0018 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/Event.h"
0019 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/EventSetup.h"
0020 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/stream/EDProducer.h"
0021 
0022 #include "DeclsForKernels.h"
0023 #include "EcalRecHitBuilder.h"
0024 
0025 namespace ALPAKA_ACCELERATOR_NAMESPACE {
0026   namespace {
0027     using EcalRecHitParametersCache =
0028         cms::alpakatools::MoveToDeviceCache<Device, PortableHostObject<EcalRecHitParameters>>;
0029   }
0030 
0031   class EcalRecHitProducerPortable : public stream::EDProducer<edm::GlobalCache<EcalRecHitParametersCache>> {
0032   public:
0033     explicit EcalRecHitProducerPortable(edm::ParameterSet const& ps, EcalRecHitParametersCache const*);
0034     ~EcalRecHitProducerPortable() override = default;
0035     static void fillDescriptions(edm::ConfigurationDescriptions&);
0036     static std::unique_ptr<EcalRecHitParametersCache> initializeGlobalCache(edm::ParameterSet const& ps);
0037 
0038     void produce(device::Event&, device::EventSetup const&) override;
0039 
0040     static void globalEndJob(EcalRecHitParametersCache*) {}
0041 
0042   private:
0043     bool const isPhase2_;
0044     // input
0045     using InputProduct = EcalUncalibratedRecHitDeviceCollection;
0046     const device::EDGetToken<InputProduct> uncalibRecHitsTokenEB_;
0047     const device::EDGetToken<InputProduct> uncalibRecHitsTokenEE_;
0048     // output
0049     using OutputProduct = EcalRecHitDeviceCollection;
0050     const device::EDPutToken<OutputProduct> recHitsTokenEB_;
0051     device::EDPutToken<OutputProduct> recHitsTokenEE_;
0052 
0053     // configuration parameters
0054     ecal::rechit::ConfigurationParameters configParameters_;
0055 
0056     // conditions tokens
0057     const device::ESGetToken<EcalRecHitConditionsDevice, EcalRecHitConditionsRcd> recHitConditionsToken_;
0058   };
0059 
0060   void EcalRecHitProducerPortable::fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
0061     edm::ParameterSetDescription desc;
0062 
0063     desc.add<edm::InputTag>("uncalibrecHitsInLabelEB",
0064                             edm::InputTag("ecalMultiFitUncalibRecHitPortable", "EcalUncalibRecHitsEB"));
0065     desc.add<std::string>("recHitsLabelEB", "EcalRecHitsEB");
0066     desc.add<bool>("killDeadChannels", true);
0067     desc.add<bool>("recoverEBIsolatedChannels", false);
0068     desc.add<bool>("recoverEBVFE", false);
0069     desc.add<bool>("recoverEBFE", true);
0070 
0071     desc.add<double>("EBLaserMIN", 0.5);
0072     desc.add<double>("EBLaserMAX", 3.0);
0073 
0074     desc.ifValue(edm::ParameterDescription<bool>("isPhase2", false, true),
0075                  false >> (edm::ParameterDescription<edm::InputTag>(
0076                                "uncalibrecHitsInLabelEE",
0077                                edm::InputTag("ecalMultiFitUncalibRecHitPortable", "EcalUncalibRecHitsEE"),
0078                                true) and
0079                            edm::ParameterDescription<std::string>("recHitsLabelEE", "EcalRecHitsEE", true) and
0080                            edm::ParameterDescription<bool>("recoverEEIsolatedChannels", false, true) and
0081                            edm::ParameterDescription<bool>("recoverEEVFE", false, true) and
0082                            edm::ParameterDescription<bool>("recoverEEFE", true, true) and
0083                            edm::ParameterDescription<double>("EELaserMIN", 0.5, true) and
0084                            edm::ParameterDescription<double>("EELaserMAX", 8.0, true)) or
0085                      true >> edm::EmptyGroupDescription());
0086 
0087     // channel statuses to be exluded from reconstruction
0088     desc.add<std::vector<std::string>>("ChannelStatusToBeExcluded",
0089                                        {"kDAC",
0090                                         "kNoisy",
0091                                         "kNNoisy",
0092                                         "kFixedG6",
0093                                         "kFixedG1",
0094                                         "kFixedG0",
0095                                         "kNonRespondingIsolated",
0096                                         "kDeadVFE",
0097                                         "kDeadFE",
0098                                         "kNoDataNoTP"});
0099 
0100     // reco flags association to channel status flags
0101     edm::ParameterSetDescription psd0;
0102     psd0.add<std::vector<std::string>>("kGood", {"kOk", "kDAC", "kNoLaser", "kNoisy"});
0103     psd0.add<std::vector<std::string>>("kNeighboursRecovered", {"kFixedG0", "kNonRespondingIsolated", "kDeadVFE"});
0104     psd0.add<std::vector<std::string>>("kDead", {"kNoDataNoTP"});
0105     psd0.add<std::vector<std::string>>("kNoisy", {"kNNoisy", "kFixedG6", "kFixedG1"});
0106     psd0.add<std::vector<std::string>>("kTowerRecovered", {"kDeadFE"});
0107     desc.add<edm::ParameterSetDescription>("flagsMapDBReco", psd0);
0108 
0109     confDesc.addWithDefaultLabel(desc);
0110   }
0111 
0112   std::unique_ptr<EcalRecHitParametersCache> EcalRecHitProducerPortable::initializeGlobalCache(
0113       edm::ParameterSet const& ps) {
0114     PortableHostObject<EcalRecHitParameters> params(cms::alpakatools::host());
0115 
0116     // Translate string representation of ChannelStatusToBeExcluded to enum values and pack into bitset
0117     auto const& channelStatusToBeExcluded = StringToEnumValue<EcalChannelStatusCode::Code>(
0118         ps.getParameter<std::vector<std::string>>("ChannelStatusToBeExcluded"));
0119     for (auto const& st : channelStatusToBeExcluded) {
0120       params->channelStatusCodesToBeExcluded.set(st);
0121     }
0122 
0123     // Generate map of channel status codes and corresponding recoFlag bits
0124     auto const& fmdbRecoPset = ps.getParameter<edm::ParameterSet>("flagsMapDBReco");
0125     auto const& recoFlagStrings = fmdbRecoPset.getParameterNames();
0126     for (auto const& recoFlagString : recoFlagStrings) {
0127       auto const recoFlag = static_cast<EcalRecHit::Flags>(StringToEnumValue<EcalRecHit::Flags>(recoFlagString));
0128       auto const& channelStatusCodeStrings = fmdbRecoPset.getParameter<std::vector<std::string>>(recoFlagString);
0129       for (auto const& channelStatusCodeString : channelStatusCodeStrings) {
0130         auto const chStatCode = StringToEnumValue<EcalChannelStatusCode::Code>(channelStatusCodeString);
0131         // set recoFlagBits for this channel status code
0132         params->recoFlagBits.at(chStatCode) = static_cast<uint32_t>(recoFlag);
0133       }
0134     }
0135 
0136     return std::make_unique<EcalRecHitParametersCache>(std::move(params));
0137   }
0138 
0139   EcalRecHitProducerPortable::EcalRecHitProducerPortable(const edm::ParameterSet& ps, EcalRecHitParametersCache const*)
0140       : EDProducer(ps),
0141         isPhase2_{ps.getParameter<bool>("isPhase2")},
0142         uncalibRecHitsTokenEB_{consumes(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEB"))},
0143         uncalibRecHitsTokenEE_{isPhase2_ ? device::EDGetToken<InputProduct>{}
0144                                          : consumes(ps.getParameter<edm::InputTag>("uncalibrecHitsInLabelEE"))},
0145         recHitsTokenEB_{produces(ps.getParameter<std::string>("recHitsLabelEB"))},
0146         recHitConditionsToken_{esConsumes()} {
0147     if (!isPhase2_) {
0148       recHitsTokenEE_ = produces(ps.getParameter<std::string>("recHitsLabelEE"));
0149     }
0150     configParameters_.killDeadChannels = ps.getParameter<bool>("killDeadChannels");
0151     configParameters_.EBLaserMIN = ps.getParameter<double>("EBLaserMIN");
0152     configParameters_.EELaserMIN = isPhase2_ ? 0. : ps.getParameter<double>("EELaserMIN");
0153     configParameters_.EBLaserMAX = ps.getParameter<double>("EBLaserMAX");
0154     configParameters_.EELaserMAX = isPhase2_ ? 0. : ps.getParameter<double>("EELaserMAX");
0155 
0156     // do not propagate channels with these flags on
0157     uint32_t flagmask = 0;
0158     flagmask |= 0x1 << EcalRecHit::kNeighboursRecovered;
0159     flagmask |= 0x1 << EcalRecHit::kTowerRecovered;
0160     flagmask |= 0x1 << EcalRecHit::kDead;
0161     flagmask |= 0x1 << EcalRecHit::kKilled;
0162     flagmask |= 0x1 << EcalRecHit::kTPSaturated;
0163     flagmask |= 0x1 << EcalRecHit::kL1SpikeFlag;
0164     configParameters_.flagmask = flagmask;
0165 
0166     // for recovery and killing
0167     configParameters_.recoverEBIsolatedChannels = ps.getParameter<bool>("recoverEBIsolatedChannels");
0168     configParameters_.recoverEEIsolatedChannels =
0169         isPhase2_ ? false : ps.getParameter<bool>("recoverEEIsolatedChannels");
0170     configParameters_.recoverEBVFE = ps.getParameter<bool>("recoverEBVFE");
0171     configParameters_.recoverEEVFE = isPhase2_ ? false : ps.getParameter<bool>("recoverEEVFE");
0172     configParameters_.recoverEBFE = ps.getParameter<bool>("recoverEBFE");
0173     configParameters_.recoverEEFE = isPhase2_ ? false : ps.getParameter<bool>("recoverEEFE");
0174   }
0175 
0176   void EcalRecHitProducerPortable::produce(device::Event& event, device::EventSetup const& setup) {
0177     auto& queue = event.queue();
0178 
0179     // get device collections from event
0180     auto const* uncalibRecHitsDevEB = &event.get(uncalibRecHitsTokenEB_);
0181     auto const* uncalibRecHitsDevEE = isPhase2_ ? nullptr : &event.get(uncalibRecHitsTokenEE_);
0182 
0183     // get the size of the input collections from the metadata
0184     auto const uncalibRecHitsSizeEB = uncalibRecHitsDevEB->const_view().metadata().size();
0185     auto const uncalibRecHitsSizeEE = isPhase2_ ? 0 : uncalibRecHitsDevEE->const_view().metadata().size();
0186 
0187     // output device collections with the same size than the input collections
0188     auto recHitsDevEB = std::make_unique<OutputProduct>(uncalibRecHitsSizeEB, queue);
0189     auto recHitsDevEE =
0190         isPhase2_ ? std::unique_ptr<OutputProduct>() : std::make_unique<OutputProduct>(uncalibRecHitsSizeEE, queue);
0191     // reset the size scalar of the SoA
0192     // memset takes an alpaka view that is created from the scalar in a view to the portable device collection
0193     auto recHitSizeViewEB = cms::alpakatools::make_device_view<uint32_t>(queue, recHitsDevEB->view().size());
0194     alpaka::memset(queue, recHitSizeViewEB, 0);
0195 
0196     if (!isPhase2_) {
0197       auto recHitSizeViewEE = cms::alpakatools::make_device_view<uint32_t>(queue, recHitsDevEE->view().size());
0198       alpaka::memset(queue, recHitSizeViewEE, 0);
0199     }
0200 
0201     // stop here if there are no uncalibrated rechits
0202     if (uncalibRecHitsSizeEB + uncalibRecHitsSizeEE > 0) {
0203       // to get the event time from device::Event one has to access the underlying edm::Event
0204       auto const& eventTime = static_cast<const edm::Event&>(event).time().value();
0205 
0206       // conditions
0207       auto const& recHitConditionsDev = setup.getData(recHitConditionsToken_);
0208       auto const* recHitParametersDev = globalCache()->get(queue).const_data();
0209 
0210       //
0211       // schedule algorithms
0212       //
0213       ecal::rechit::create_ecal_rechit(queue,
0214                                        uncalibRecHitsDevEB,
0215                                        uncalibRecHitsDevEE,
0216                                        *recHitsDevEB,
0217                                        *recHitsDevEE,
0218                                        recHitConditionsDev,
0219                                        recHitParametersDev,
0220                                        eventTime,
0221                                        configParameters_,
0222                                        isPhase2_);
0223     }
0224 
0225     // put collections into the event
0226     event.put(recHitsTokenEB_, std::move(recHitsDevEB));
0227     if (!isPhase2_) {
0228       event.put(recHitsTokenEE_, std::move(recHitsDevEE));
0229     }
0230   }
0231 
0232 }  // namespace ALPAKA_ACCELERATOR_NAMESPACE
0233 
0234 #include "HeterogeneousCore/AlpakaCore/interface/alpaka/MakerMacros.h"
0235 DEFINE_FWK_ALPAKA_MODULE(EcalRecHitProducerPortable);