Move common ESProducer templates to ConvertingESProducer(WithDependencies)T

EventFilter/EcalRawToDigi/plugins/EcalRawESProducersGPUDefs.cc

@@ -1,12 +1,9 @@
-#include "EcalRawESProducerGPU.h"
-
 #include "CondFormats/DataRecord/interface/EcalMappingElectronicsRcd.h"
-
 #include "EventFilter/EcalRawToDigi/interface/ElectronicsMappingGPU.h"
-
-#include <iostream>
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h"
 
 using EcalElectronicsMappingGPUESProducer =
-    EcalRawESProducerGPU<ecal::raw::ElectronicsMappingGPU, EcalMappingElectronics, EcalMappingElectronicsRcd>;
+    ConvertingESProducerT<EcalMappingElectronicsRcd, ecal::raw::ElectronicsMappingGPU, EcalMappingElectronics>;
 
 DEFINE_FWK_EVENTSETUP_MODULE(EcalElectronicsMappingGPUESProducer);

EventFilter/HcalRawToDigi/plugins/HcalESProducerGPUDefs.cc

@@ -1,11 +1,10 @@
-#include <iostream>
-
 #include "CondFormats/DataRecord/interface/HcalElectronicsMapRcd.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h"
 
 #include "ElectronicsMappingGPU.h"
-#include "HcalRawESProducerGPU.h"
 
 using HcalElectronicsMappingGPUESProducer =
-    HcalRawESProducerGPU<hcal::raw::ElectronicsMappingGPU, HcalElectronicsMap, HcalElectronicsMapRcd>;
+    ConvertingESProducerT<HcalElectronicsMapRcd, hcal::raw::ElectronicsMappingGPU, HcalElectronicsMap>;
 
 DEFINE_FWK_EVENTSETUP_MODULE(HcalElectronicsMappingGPUESProducer);

EventFilter/HcalRawToDigi/plugins/HcalRawESProducerGPU.h → HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h

@@ -1,7 +1,5 @@
-#ifndef RecoLocalCalo_HcalRecProducers_src_HcalRawESProducerGPU_h
-#define RecoLocalCalo_HcalRecProducers_src_HcalRawESProducerGPU_h
-
-#include <iostream>
+#ifndef HeterogeneousCore_CUDACore_interface_ConvertingESProducerT_h
+#define HeterogeneousCore_CUDACore_interface_ConvertingESProducerT_h
 
 #include "FWCore/Framework/interface/ESProducer.h"
 #include "FWCore/Framework/interface/ESTransientHandle.h"
@@ -11,33 +9,31 @@
 #include "FWCore/ParameterSet/interface/ParameterSet.h"
 #include "FWCore/Utilities/interface/typelookup.h"
 
-template <typename Target, typename Source, typename Record>
-class HcalRawESProducerGPU : public edm::ESProducer {
+template <typename Record, typename Target, typename Source>
+class ConvertingESProducerT : public edm::ESProducer {
 public:
-  explicit HcalRawESProducerGPU(edm::ParameterSet const& ps) {
+  explicit ConvertingESProducerT(edm::ParameterSet const& ps) {
     auto const& label = ps.getParameter<std::string>("label");
     auto const& name = ps.getParameter<std::string>("ComponentName");
     auto cc = setWhatProduced(this, name);
     token_ = cc.consumes(edm::ESInputTag{"", label});
   }
 
   std::unique_ptr<Target> produce(Record const& record) {
-    // retrieve conditions in old format
-    auto sourceProduct = record.getTransientHandle(token_);
-
-    return std::make_unique<Target>(*sourceProduct);
+    // retrieve conditions in the old format and build a product in the new format
+    return std::make_unique<Target>(record.get(token_));
   }
 
   static void fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
     edm::ParameterSetDescription desc;
 
     desc.add<std::string>("ComponentName", "");
-    desc.add<std::string>("label", "")->setComment("Product Label");
+    desc.add<std::string>("label", "")->setComment("ESProduct label");
     confDesc.addWithDefaultLabel(desc);
   }
 
 private:
   edm::ESGetToken<Source, Record> token_;
 };
 
-#endif
+#endif  // HeterogeneousCore_CUDACore_interface_ConvertingESProducerT_h

HeterogeneousCore/CUDACore/interface/ConvertingESProducerWithDependenciesT.h

@@ -0,0 +1,110 @@
+#ifndef HeterogeneousCore_CUDACore_interface_ConvertingESProducerWithDependenciesT_h
+#define HeterogeneousCore_CUDACore_interface_ConvertingESProducerWithDependenciesT_h
+
+#include <tuple>
+#include <utility>
+
+#include "FWCore/Framework/interface/ESProducer.h"
+#include "FWCore/Framework/interface/ESHandle.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "FWCore/Framework/interface/ModuleFactory.h"
+#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h"
+#include "FWCore/ParameterSet/interface/ParameterSet.h"
+#include "FWCore/Utilities/interface/typelookup.h"
+
+namespace detail {
+  // simple implementation of a type zipper over 2 tuples
+  // here, the main requirement is the default constructor for Gen template
+  // which __does__ exist for ESGetToken
+
+  template <template <typename, typename> class Gen, typename Tuple1, typename Tuple2>
+  struct TypeZipper;
+
+  template <template <typename, typename> class Gen, typename Tuple1, typename Tuple2, std::size_t... Is>
+  auto TypeZipperImpl(Tuple1 const& t1, Tuple2 const& t2, std::index_sequence<Is...>) {
+    return std::make_tuple(
+        Gen<typename std::tuple_element<Is, Tuple1>::type, typename std::tuple_element<Is, Tuple2>::type>{}...);
+  }
+
+  template <template <typename, typename> class Gen, typename... Ts1, typename... Ts2>
+  struct TypeZipper<Gen, std::tuple<Ts1...>, std::tuple<Ts2...>> {
+    static_assert(sizeof...(Ts1) == sizeof...(Ts2));
+    using type = typename std::decay<decltype(
+        TypeZipperImpl<Gen>(std::tuple<Ts1...>{}, std::tuple<Ts2...>{}, std::index_sequence_for<Ts1...>{}))>::type;
+  };
+
+}  // namespace detail
+
+template <typename CombinedRecord, typename Target, typename... Dependencies>
+class ConvertingESProducerWithDependenciesT;
+
+template <template <typename...> typename CombinedRecord,
+          typename... DepsRecords,
+          typename Target,
+          typename... Dependencies>
+class ConvertingESProducerWithDependenciesT<CombinedRecord<DepsRecords...>, Target, Dependencies...>
+    : public edm::ESProducer {
+public:
+  static constexpr std::size_t nsources = sizeof...(Dependencies);
+  static_assert(sizeof...(Dependencies) == sizeof...(DepsRecords));
+
+  explicit ConvertingESProducerWithDependenciesT(edm::ParameterSet const& ps) {
+    std::vector<edm::ESInputTag> tags(nsources);
+    for (std::size_t i = 0; i < nsources; i++)
+      tags[i] = edm::ESInputTag{"", ps.getParameter<std::string>("label" + std::to_string(i))};
+
+    std::string const& name = ps.getParameter<std::string>("ComponentName");
+    edm::ESConsumesCollectorT<CombinedRecord<DepsRecords...>> cc = setWhatProduced(this, name);
+    WalkConsumes<nsources - 1>::iterate(cc, tokens_, tags);
+  }
+
+  std::unique_ptr<Target> produce(CombinedRecord<DepsRecords...> const& record) {
+    auto handles = std::tuple<edm::ESHandle<Dependencies>...>{};
+    WalkAndCall<nsources - 1, edm::ESHandle<Dependencies>...>::iterate(record, handles, tokens_);
+
+    return std::apply([](auto const&... handles) { return std::make_unique<Target>((*handles)...); }, handles);
+  }
+
+  static void fillDescriptions(edm::ConfigurationDescriptions& confDesc) {
+    edm::ParameterSetDescription desc;
+
+    desc.add<std::string>("ComponentName", "");
+    for (std::size_t i = 0; i < nsources; i++)
+      desc.add<std::string>("label" + std::to_string(i), "")->setComment("Product Label");
+    confDesc.addWithDefaultLabel(desc);
+  }
+
+private:
+  using TokenType =
+      typename detail::TypeZipper<edm::ESGetToken, std::tuple<Dependencies...>, std::tuple<DepsRecords...>>::type;
+  TokenType tokens_;
+
+private:
+  template <std::size_t N>
+  struct WalkConsumes {
+    static void iterate(edm::ESConsumesCollectorT<CombinedRecord<DepsRecords...>>& cc,
+                        TokenType& tokens,
+                        std::vector<edm::ESInputTag> const& tags) {
+      if constexpr (N > 0)
+        WalkConsumes<N - 1>::iterate(cc, tokens, tags);
+      std::get<N>(tokens) = cc.consumes(tags[N]);
+    }
+  };
+
+  template <std::size_t N, typename... Types>
+  struct WalkAndCall {
+    static void iterate(CombinedRecord<DepsRecords...> const& containingRecord,
+                        std::tuple<Types...>& ts,
+                        TokenType const& tokens) {
+      using Record = typename std::tuple_element<N, std::tuple<DepsRecords...>>::type;
+      if constexpr (N > 0)
+        WalkAndCall<N - 1, Types...>::iterate(containingRecord, ts, tokens);
+      // get the right dependent record
+      auto const& record = containingRecord.template getRecord<Record>();
+      // assign the right element of the tuple
+      std::get<N>(ts) = record.getHandle(std::get<N>(tokens));
+    }
+  };
+};
+
+#endif  // HeterogeneousCore_CUDACore_interface_ConvertingESProducerWithDependenciesT_h

RecoLocalCalo/EcalRecProducers/plugins/EcalESProducersGPUDefs.cc

@@ -1,81 +1,74 @@
-#include "EcalESProducerGPU.h"
-
-// for uncalibrechit
-#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
-#include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"
-#include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
-// for rechit
 #include "CondFormats/DataRecord/interface/EcalADCToGeVConstantRcd.h"
-#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
 #include "CondFormats/DataRecord/interface/EcalChannelStatusRcd.h"
+#include "CondFormats/DataRecord/interface/EcalGainRatiosRcd.h"
+#include "CondFormats/DataRecord/interface/EcalIntercalibConstantsRcd.h"
 #include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRcd.h"
 #include "CondFormats/DataRecord/interface/EcalLaserAPDPNRatiosRefRcd.h"
 #include "CondFormats/DataRecord/interface/EcalLaserAlphasRcd.h"
 #include "CondFormats/DataRecord/interface/EcalLinearCorrectionsRcd.h"
-
-// for uncalibrechit
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h"
+#include "CondFormats/DataRecord/interface/EcalPedestalsRcd.h"
+#include "CondFormats/DataRecord/interface/EcalPulseCovariancesRcd.h"
+#include "CondFormats/DataRecord/interface/EcalPulseShapesRcd.h"
+#include "CondFormats/DataRecord/interface/EcalSamplesCorrelationRcd.h"
+#include "CondFormats/DataRecord/interface/EcalTimeBiasCorrectionsRcd.h"
+#include "CondFormats/DataRecord/interface/EcalTimeCalibConstantsRcd.h"
+#include "FWCore/Framework/interface/MakerMacros.h"
+#include "HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalGainRatiosGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h"
-// for rechit
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitADCToGeVConstantGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalIntercalibConstantsGPU.h"
-#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitChannelStatusGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalLaserAPDPNRatiosGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalLaserAPDPNRatiosRefGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalLaserAlphasGPU.h"
 #include "RecoLocalCalo/EcalRecAlgos/interface/EcalLinearCorrectionsGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPedestalsGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPulseCovariancesGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalPulseShapesGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitADCToGeVConstantGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalRechitChannelStatusGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalSamplesCorrelationGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeBiasCorrectionsGPU.h"
+#include "RecoLocalCalo/EcalRecAlgos/interface/EcalTimeCalibConstantsGPU.h"
 
-#include <iostream>
-
-using EcalPedestalsGPUESProducer = EcalESProducerGPU<EcalPedestalsGPU, EcalPedestals, EcalPedestalsRcd>;
+using EcalPedestalsGPUESProducer = ConvertingESProducerT<EcalPedestalsRcd, EcalPedestalsGPU, EcalPedestals>;
 
-using EcalGainRatiosGPUESProducer = EcalESProducerGPU<EcalGainRatiosGPU, EcalGainRatios, EcalGainRatiosRcd>;
+using EcalGainRatiosGPUESProducer = ConvertingESProducerT<EcalGainRatiosRcd, EcalGainRatiosGPU, EcalGainRatios>;
 
-using EcalPulseShapesGPUESProducer = EcalESProducerGPU<EcalPulseShapesGPU, EcalPulseShapes, EcalPulseShapesRcd>;
+using EcalPulseShapesGPUESProducer = ConvertingESProducerT<EcalPulseShapesRcd, EcalPulseShapesGPU, EcalPulseShapes>;
 
 using EcalPulseCovariancesGPUESProducer =
-    EcalESProducerGPU<EcalPulseCovariancesGPU, EcalPulseCovariances, EcalPulseCovariancesRcd>;
+    ConvertingESProducerT<EcalPulseCovariancesRcd, EcalPulseCovariancesGPU, EcalPulseCovariances>;
 
 using EcalSamplesCorrelationGPUESProducer =
-    EcalESProducerGPU<EcalSamplesCorrelationGPU, EcalSamplesCorrelation, EcalSamplesCorrelationRcd>;
+    ConvertingESProducerT<EcalSamplesCorrelationRcd, EcalSamplesCorrelationGPU, EcalSamplesCorrelation>;
 
 using EcalTimeBiasCorrectionsGPUESProducer =
-    EcalESProducerGPU<EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrections, EcalTimeBiasCorrectionsRcd>;
+    ConvertingESProducerT<EcalTimeBiasCorrectionsRcd, EcalTimeBiasCorrectionsGPU, EcalTimeBiasCorrections>;
 
 using EcalTimeCalibConstantsGPUESProducer =
-    EcalESProducerGPU<EcalTimeCalibConstantsGPU, EcalTimeCalibConstants, EcalTimeCalibConstantsRcd>;
+    ConvertingESProducerT<EcalTimeCalibConstantsRcd, EcalTimeCalibConstantsGPU, EcalTimeCalibConstants>;
 
 using EcalRechitADCToGeVConstantGPUESProducer =
-    EcalESProducerGPU<EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstant, EcalADCToGeVConstantRcd>;
+    ConvertingESProducerT<EcalADCToGeVConstantRcd, EcalRechitADCToGeVConstantGPU, EcalADCToGeVConstant>;
 
 using EcalIntercalibConstantsGPUESProducer =
-    EcalESProducerGPU<EcalIntercalibConstantsGPU, EcalIntercalibConstants, EcalIntercalibConstantsRcd>;
+    ConvertingESProducerT<EcalIntercalibConstantsRcd, EcalIntercalibConstantsGPU, EcalIntercalibConstants>;
 
 using EcalRechitChannelStatusGPUESProducer =
-    EcalESProducerGPU<EcalRechitChannelStatusGPU, EcalChannelStatus, EcalChannelStatusRcd>;
+    ConvertingESProducerT<EcalChannelStatusRcd, EcalRechitChannelStatusGPU, EcalChannelStatus>;
 
 using EcalLaserAPDPNRatiosGPUESProducer =
-    EcalESProducerGPU<EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatios, EcalLaserAPDPNRatiosRcd>;
+    ConvertingESProducerT<EcalLaserAPDPNRatiosRcd, EcalLaserAPDPNRatiosGPU, EcalLaserAPDPNRatios>;
 
 using EcalLaserAPDPNRatiosRefGPUESProducer =
-    EcalESProducerGPU<EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRef, EcalLaserAPDPNRatiosRefRcd>;
+    ConvertingESProducerT<EcalLaserAPDPNRatiosRefRcd, EcalLaserAPDPNRatiosRefGPU, EcalLaserAPDPNRatiosRef>;
 
-using EcalLaserAlphasGPUESProducer = EcalESProducerGPU<EcalLaserAlphasGPU, EcalLaserAlphas, EcalLaserAlphasRcd>;
+using EcalLaserAlphasGPUESProducer = ConvertingESProducerT<EcalLaserAlphasRcd, EcalLaserAlphasGPU, EcalLaserAlphas>;
 
 using EcalLinearCorrectionsGPUESProducer =
-    EcalESProducerGPU<EcalLinearCorrectionsGPU, EcalLinearCorrections, EcalLinearCorrectionsRcd>;
+    ConvertingESProducerT<EcalLinearCorrectionsRcd, EcalLinearCorrectionsGPU, EcalLinearCorrections>;
 
 //
-// This below also creates the .py config files, as described in "EcalESProducerGPU.h"
+// This below also creates the .py config files, as described in HeterogeneousCore/CUDACore/interface/ConvertingESProducerT.h
 //
 
 DEFINE_FWK_EVENTSETUP_MODULE(EcalPedestalsGPUESProducer);