Synchronise with CMSSW_11_2_0_pre10

CUDADataFormats/Common/BuildFile.xml

@@ -1,5 +1,7 @@
 <iftool name="cuda">
+  <use name="DataFormats/Common"/>
   <use name="HeterogeneousCore/CUDAUtilities"/>
+  <use name="rootcore"/>
   <export>
     <lib name="1"/>
   </export>

CUDADataFormats/Common/src/classes.h

@@ -0,0 +1,7 @@
+#ifndef CUDADataFormats_Common_src_classes_h
+#define CUDADataFormats_Common_src_classes_h
+
+#include "CUDADataFormats/Common/interface/HostProduct.h"
+#include "DataFormats/Common/interface/Wrapper.h"
+
+#endif  // CUDADataFormats_Common_src_classes_h

CUDADataFormats/Common/src/classes_def.xml

@@ -0,0 +1,4 @@
+<lcgdict>
+  <class name="HostProduct<unsigned int[]>" persistent="false"/>
+  <class name="edm::Wrapper<HostProduct<unsigned int[]>>" persistent="false"/>
+</lcgdict>

CUDADataFormats/EcalDigi/BuildFile.xml

@@ -0,0 +1,8 @@
+<use name="CUDADataFormats/Common"/>
+<use name="CUDADataFormats/CaloCommon"/>
+<use name="DataFormats/Common"/>
+<use name="HeterogeneousCore/CUDAUtilities"/>
+
+<export>
+  <lib   name="1"/>
+</export>

CUDADataFormats/EcalDigi/interface/DigisCollection.h

@@ -0,0 +1,24 @@
+#ifndef CUDADataFormats_EcalDigi_interface_DigisCollection_h
+#define CUDADataFormats_EcalDigi_interface_DigisCollection_h
+
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+
+namespace ecal {
+
+  template <typename StoragePolicy>
+  struct DigisCollection : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    DigisCollection() = default;
+    DigisCollection(DigisCollection const &) = default;
+    DigisCollection &operator=(DigisCollection const &) = default;
+
+    DigisCollection(DigisCollection &&) = default;
+    DigisCollection &operator=(DigisCollection &&) = default;
+
+    // stride is statically known
+    typename StoragePolicy::template StorageSelector<uint32_t>::type ids;
+    typename StoragePolicy::template StorageSelector<uint16_t>::type data;
+  };
+
+}  // namespace ecal
+
+#endif  // CUDADataFormats_EcalDigi_interface_DigisCollection_h

CUDADataFormats/EcalDigi/src/classes.h

@@ -0,0 +1,3 @@
+#include "CUDADataFormats/Common/interface/Product.h"
+#include "CUDADataFormats/EcalDigi/interface/DigisCollection.h"
+#include "DataFormats/Common/interface/Wrapper.h"

CUDADataFormats/EcalDigi/src/classes_def.xml

@@ -0,0 +1,6 @@
+<lcgdict>
+    <class name="cms::cuda::Product<ecal::DigisCollection<calo::common::ViewStoragePolicy>>" persistent="false" />
+    <class name="cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>" persistent="false" />
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::DigisCollection<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::DigisCollection<calo::common::DevStoragePolicy>>>" persistent="false"/>
+</lcgdict>

CUDADataFormats/EcalRecHitSoA/BuildFile.xml

@@ -0,0 +1,10 @@
+<use name="cuda"/>
+<use name="CUDADataFormats/Common"/>
+<use name="CUDADataFormats/CaloCommon"/>
+<use name="DataFormats/Common"/>
+<use name="DataFormats/EcalDigi"/>
+<use name="HeterogeneousCore/CUDAUtilities"/>
+
+<export>
+  <lib   name="1"/>
+</export>

CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h

@@ -0,0 +1,45 @@
+#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h
+#define CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h
+
+#include <array>
+#include <vector>
+
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
+#include "HeterogeneousCore/CUDAUtilities/interface/HostAllocator.h"
+
+namespace ecal {
+
+  template <typename StoragePolicy>
+  struct RecHit : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    RecHit() = default;
+    RecHit(const RecHit&) = default;
+    RecHit& operator=(const RecHit&) = default;
+
+    RecHit(RecHit&&) = default;
+    RecHit& operator=(RecHit&&) = default;
+
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type energy;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type time;
+    // should we remove the following, since already included in "extra" ?
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type chi2;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type
+        extra;  // packed uint32_t for timeError, chi2, energyError
+    typename StoragePolicy::template StorageSelector<uint32_t>::type
+        flagBits;  // store rechit condition (see Flags enum) in a bit-wise way
+    typename StoragePolicy::template StorageSelector<uint32_t>::type did;
+
+    template <typename U = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<U, ::calo::common::tags::Vec>::value, void>::type resize(size_t size) {
+      energy.resize(size);
+      time.resize(size);
+      chi2.resize(size);
+      extra.resize(size);
+      flagBits.resize(size);
+      did.resize(size);
+    }
+  };
+
+}  // namespace ecal
+
+#endif  // CUDADataFormats_EcalRecHitSoA_interface_EcalRecHit_h

CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h

@@ -0,0 +1,46 @@
+#ifndef CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
+#define CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h
+
+#include <array>
+#include <vector>
+
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h"
+#include "DataFormats/EcalDigi/interface/EcalDataFrame.h"
+
+namespace ecal {
+
+  template <typename StoragePolicy>
+  struct UncalibratedRecHit : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    UncalibratedRecHit() = default;
+    UncalibratedRecHit(const UncalibratedRecHit&) = default;
+    UncalibratedRecHit& operator=(const UncalibratedRecHit&) = default;
+
+    UncalibratedRecHit(UncalibratedRecHit&&) = default;
+    UncalibratedRecHit& operator=(UncalibratedRecHit&&) = default;
+
+    typename StoragePolicy::template StorageSelector<reco::ComputationScalarType>::type amplitudesAll;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type amplitude;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type chi2;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type pedestal;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type jitter;
+    typename StoragePolicy::template StorageSelector<reco::StorageScalarType>::type jitterError;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type did;
+    typename StoragePolicy::template StorageSelector<uint32_t>::type flags;
+
+    template <typename U = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<U, ::calo::common::tags::Vec>::value, void>::type resize(size_t size) {
+      amplitudesAll.resize(size * EcalDataFrame::MAXSAMPLES);
+      amplitude.resize(size);
+      pedestal.resize(size);
+      chi2.resize(size);
+      did.resize(size);
+      flags.resize(size);
+      jitter.resize(size);
+      jitterError.resize(size);
+    }
+  };
+
+}  // namespace ecal
+
+#endif  // CUDADataFormats_EcalRecHitSoA_interface_EcalUncalibratedRecHit_h

CUDADataFormats/EcalRecHitSoA/interface/RecoTypes.h

@@ -0,0 +1,13 @@
+#ifndef CUDADataFormats_EcalRecHitSoA_interface_RecoTypes_h
+#define CUDADataFormats_EcalRecHitSoA_interface_RecoTypes_h
+
+namespace ecal {
+  namespace reco {
+
+    using ComputationScalarType = float;
+    using StorageScalarType = float;
+
+  }  // namespace reco
+}  // namespace ecal
+
+#endif  // CUDADataFormats_EcalRecHitSoA_interface_RecoTypes_h

CUDADataFormats/EcalRecHitSoA/src/classes.h

@@ -0,0 +1,4 @@
+#include "CUDADataFormats/Common/interface/Product.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalRecHit.h"
+#include "CUDADataFormats/EcalRecHitSoA/interface/EcalUncalibratedRecHit.h"
+#include "DataFormats/Common/interface/Wrapper.h"

CUDADataFormats/EcalRecHitSoA/src/classes_def.xml

@@ -0,0 +1,20 @@
+<lcgdict>
+    <class name="cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::ViewStoragePolicy>>" persistent="false"/>
+    <class name="cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::UncalibratedRecHit<calo::common::DevStoragePolicy>>>" persistent="false"/>
+
+    <class name="cms::cuda::Product<ecal::RecHit<calo::common::ViewStoragePolicy>>" persistent="false"/>
+    <class name="cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::RecHit<calo::common::ViewStoragePolicy>>>" persistent="false"/>
+    <class name="edm::Wrapper<cms::cuda::Product<ecal::RecHit<calo::common::DevStoragePolicy>>>" persistent="false"/>
+
+    <class name="ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>"/>
+    <class name="edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>"/>
+    <class name="ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>"/>
+    <class name="edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<calo::common::CUDAHostAllocatorAlias>>>"/>
+    <class name="ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<std::allocator>>"/>
+    <class name="edm::Wrapper<ecal::UncalibratedRecHit<calo::common::VecStoragePolicy<std::allocator>>>"/>
+    <class name="ecal::RecHit<calo::common::VecStoragePolicy<std::allocator>>"/>
+    <class name="edm::Wrapper<ecal::RecHit<calo::common::VecStoragePolicy<std::allocator>>>"/>
+</lcgdict>

CUDADataFormats/HcalDigi/BuildFile.xml

@@ -0,0 +1,8 @@
+<use name="DataFormats/Common"/>
+<use name="CUDADataFormats/CaloCommon"/>
+<use name="HeterogeneousCore/CUDAUtilities"/>
+<use name="cuda"/>
+
+<export>
+  <lib   name="1"/>
+</export>

CUDADataFormats/HcalDigi/interface/DigiCollection.h

@@ -0,0 +1,160 @@
+#ifndef CUDADataFormats_HcalDigi_interface_DigiCollection_h
+#define CUDADataFormats_HcalDigi_interface_DigiCollection_h
+
+#include "CUDADataFormats/CaloCommon/interface/Common.h"
+
+namespace hcal {
+
+  // FLAVOR_HE_QIE11 = 1; Phase1 upgrade
+  struct Flavor1 {
+    static constexpr int WORDS_PER_SAMPLE = 1;
+    static constexpr int SAMPLES_PER_WORD = 1;
+    static constexpr int HEADER_WORDS = 1;
+
+    static constexpr uint8_t adc(uint16_t const* const sample_start) { return (*sample_start & 0xff); }
+    static constexpr uint8_t tdc(uint16_t const* const sample_start) { return (*sample_start >> 8) & 0x3f; }
+    static constexpr uint8_t soibit(uint16_t const* const sample_start) { return (*sample_start >> 14) & 0x1; }
+  };
+
+  // FLAVOR_HB_QIE11 = 3; Phase1 upgrade
+  struct Flavor3 {
+    static constexpr int WORDS_PER_SAMPLE = 1;
+    static constexpr int SAMPLES_PER_WORD = 1;
+    static constexpr int HEADER_WORDS = 1;
+
+    static constexpr uint8_t adc(uint16_t const* const sample_start) { return (*sample_start & 0xff); }
+    static constexpr uint8_t tdc(uint16_t const* const sample_start) { return ((*sample_start >> 8) & 0x3); }
+    static constexpr uint8_t soibit(uint16_t const* const sample_start) { return ((*sample_start >> 14) & 0x1); }
+    static constexpr uint8_t capid(uint16_t const* const sample_start) { return ((*sample_start >> 10) & 0x3); }
+  };
+
+  // FLAVOR_HB_QIE10 = 5; Phase0
+  struct Flavor5 {
+    static constexpr float WORDS_PER_SAMPLE = 0.5;
+    static constexpr int SAMPLES_PER_WORD = 2;
+    static constexpr int HEADER_WORDS = 1;
+
+    static constexpr uint8_t adc(uint16_t const* const sample_start, uint8_t const shifter) {
+      return ((*sample_start >> shifter * 8) & 0x7f);
+    }
+  };
+
+  template <typename Flavor>
+  constexpr uint8_t capid_for_sample(uint16_t const* const dfstart, uint32_t const sample) {
+    auto const capid_first = (*dfstart >> 8) & 0x3;
+    return (capid_first + sample) & 0x3;  // same as % 4
+  }
+
+  template <>
+  constexpr uint8_t capid_for_sample<Flavor3>(uint16_t const* const dfstart, uint32_t const sample) {
+    return Flavor3::capid(dfstart + Flavor3::HEADER_WORDS + sample * Flavor3::WORDS_PER_SAMPLE);
+  }
+
+  template <typename Flavor>
+  constexpr uint8_t soibit_for_sample(uint16_t const* const dfstart, uint32_t const sample) {
+    return Flavor::soibit(dfstart + Flavor::HEADER_WORDS + sample * Flavor::WORDS_PER_SAMPLE);
+  }
+
+  template <typename Flavor>
+  constexpr uint8_t adc_for_sample(uint16_t const* const dfstart, uint32_t const sample) {
+    return Flavor::adc(dfstart + Flavor::HEADER_WORDS + sample * Flavor::WORDS_PER_SAMPLE);
+  }
+
+  template <typename Flavor>
+  constexpr uint8_t tdc_for_sample(uint16_t const* const dfstart, uint32_t const sample) {
+    return Flavor::tdc(dfstart + Flavor::HEADER_WORDS + sample * Flavor::WORDS_PER_SAMPLE);
+  }
+
+  template <>
+  constexpr uint8_t adc_for_sample<Flavor5>(uint16_t const* const dfstart, uint32_t const sample) {
+    // avoid using WORDS_PER_SAMPLE and simply shift
+    return Flavor5::adc(dfstart + Flavor5::HEADER_WORDS + (sample >> 1), sample % 2);
+  }
+
+  template <typename Flavor>
+  constexpr uint32_t compute_stride(uint32_t const nsamples) {
+    return static_cast<uint32_t>(nsamples * Flavor::WORDS_PER_SAMPLE) + Flavor::HEADER_WORDS;
+  }
+
+  template <typename Flavor>
+  constexpr uint32_t compute_nsamples(uint32_t const nwords) {
+    if constexpr (Flavor::SAMPLES_PER_WORD >= 1)
+      return (nwords - Flavor::HEADER_WORDS) * Flavor::SAMPLES_PER_WORD;
+    else
+      return (nwords - Flavor::HEADER_WORDS) / Flavor::WORDS_PER_SAMPLE;
+  }
+
+  //
+  template <typename StoragePolicy>
+  struct DigiCollectionBase : public ::calo::common::AddSize<typename StoragePolicy::TagType> {
+    DigiCollectionBase() = default;
+    DigiCollectionBase(DigiCollectionBase const&) = default;
+    DigiCollectionBase& operator=(DigiCollectionBase const&) = default;
+
+    DigiCollectionBase(DigiCollectionBase&&) = default;
+    DigiCollectionBase& operator=(DigiCollectionBase&&) = default;
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type resize(std::size_t size) {
+      ids.resize(size);
+      data.resize(size * stride);
+    }
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type reserve(std::size_t size) {
+      ids.reserve(size);
+      data.reserve(size * stride);
+    }
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type clear() {
+      ids.clear();
+      data.clear();
+    }
+
+    typename StoragePolicy::template StorageSelector<uint32_t>::type ids;
+    typename StoragePolicy::template StorageSelector<uint16_t>::type data;
+    uint32_t stride{0};
+  };
+
+  template <typename Flavor, typename StoragePolicy>
+  struct DigiCollection : public DigiCollectionBase<StoragePolicy> {
+    using DigiCollectionBase<StoragePolicy>::DigiCollectionBase;
+  };
+
+  // NOTE: base ctors will not be available
+  template <typename StoragePolicy>
+  struct DigiCollection<Flavor5, StoragePolicy> : public DigiCollectionBase<StoragePolicy> {
+    DigiCollection() = default;
+
+    DigiCollection(DigiCollection const&) = default;
+    DigiCollection& operator=(DigiCollection const&) = default;
+
+    DigiCollection(DigiCollection&&) = default;
+    DigiCollection& operator=(DigiCollection&&) = default;
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type resize(std::size_t size) {
+      DigiCollectionBase<StoragePolicy>::resize(size);
+      npresamples.resize(size);
+    }
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type reserve(std::size_t size) {
+      DigiCollectionBase<StoragePolicy>::reserve(size);
+      npresamples.reserve(size);
+    }
+
+    template <typename T = typename StoragePolicy::TagType>
+    typename std::enable_if<std::is_same<T, ::calo::common::tags::Vec>::value, void>::type clear() {
+      DigiCollectionBase<StoragePolicy>::clear();
+      npresamples.clear();
+    }
+
+    // add npresamples member
+    typename StoragePolicy::template StorageSelector<uint8_t>::type npresamples;
+  };
+
+}  // namespace hcal
+
+#endif  // CUDADataFormats_HcalDigi_interface_DigiCollection_h

CUDADataFormats/HcalDigi/src/classes.h

@@ -0,0 +1,3 @@
+#include "CUDADataFormats/Common/interface/Product.h"
+#include "CUDADataFormats/HcalDigi/interface/DigiCollection.h"
+#include "DataFormats/Common/interface/Wrapper.h"