Update integration algorithms to include bank sizes

Dumpers/BinaryDumpers/src/TransposeRawBanks.cpp

@@ -43,7 +43,7 @@ using VOC = Gaudi::Functional::vector_of_const_<T>;
  */
 class TransposeRawBanks
   : public Gaudi::Functional::MergingTransformer<
-      std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()>(VOC<LHCb::RawEvent*> const&),
+      std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()>(VOC<LHCb::RawEvent*> const&),
       Gaudi::Functional::Traits::BaseClass_t<GaudiHistoAlg>> {
 public:
   /// Standard constructor
@@ -51,7 +51,7 @@ public:
 
   StatusCode initialize() override;
 
-  std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()> operator()(
+  std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()> operator()(
     VOC<LHCb::RawEvent*> const& rawEvents) const override;
 
 private:
@@ -86,11 +86,11 @@ StatusCode TransposeRawBanks::initialize()
   return StatusCode::SUCCESS;
 }
 
-std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()> TransposeRawBanks::operator()(
+std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()> TransposeRawBanks::operator()(
   VOC<LHCb::RawEvent*> const& rawEvents) const
 {
 
-  std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()> output;
+  std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()> output;
   std::array<LHCb::RawBank::View, LHCb::RawBank::types().size()> rawBanks;
 
   for (auto const* rawEvent : rawEvents) {
@@ -109,11 +109,13 @@ std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()> Tr
     auto const& banks = rawBanks[bt];
     if (banks.empty()) continue;
 
-    const uint32_t number_of_rawbanks = banks.size();
+    const uint32_t nBanks = banks.size();
     uint32_t offset = 0;
 
     std::vector<uint32_t> bankOffsets;
     std::vector<uint32_t> bankData;
+    std::vector<uint16_t> bankSizes;
+    bankSizes.reserve(nBanks);
     bankOffsets.push_back(0);
 
     for (auto& bank : banks) {
@@ -140,13 +142,14 @@ std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()> Tr
         bStart++;
         offset++;
       }
+      bankSizes.push_back(bank->size());
       bankOffsets.push_back(offset * sizeof(uint32_t));
     }
 
     // Dumping number_of_rawbanks + 1 offsets!
     DumpUtils::Writer bank_buffer;
-    bank_buffer.write(number_of_rawbanks, bankOffsets, bankData);
-    output[bt] = std::tuple {bank_buffer.buffer(), banks[0]->version()};
+    bank_buffer.write(nBanks, bankOffsets, bankData);
+    output[bt] = std::tuple {bank_buffer.buffer(), std::move(bankSizes), banks[0]->version()};
   }
   return output;
 }

Rec/Allen/src/ProvideRuntimeOptions.cpp

@@ -22,7 +22,7 @@
 #include <Logger.h>
 
 class ProvideRuntimeOptions final : public Gaudi::Functional::Transformer<RuntimeOptions(
-                                      std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::LastType> const&)> {
+  std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::LastType> const&)> {
 
 public:
   /// Standard constructor
@@ -32,7 +32,7 @@ public:
 
   /// Algorithm execution
   RuntimeOptions operator()(
-    std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::LastType> const& allen_banks) const override;
+    std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::LastType> const& allen_banks) const override;
 
 private:
   Gaudi::Property<std::string> m_monitorFile {this, "MonitorFile", "allen_monitor.root"};
@@ -57,7 +57,7 @@ StatusCode ProvideRuntimeOptions::initialize()
 }
 
 RuntimeOptions ProvideRuntimeOptions::operator()(
-  std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::LastType> const& allen_banks) const
+  std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::LastType> const& allen_banks) const
 {
   const unsigned number_of_repetitions = 1;
   const bool do_check = false;

Rec/Allen/src/RunAllen.cpp

@@ -178,7 +178,7 @@ StatusCode RunAllen::finalize()
 /** Calls Allen for one event
  */
 std::tuple<bool, HostBuffers> RunAllen::operator()(
-  const std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()>& allen_banks,
+  const std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()>& allen_banks,
   const LHCb::ODIN& odin) const
 {
   // Ensure non-event-data is up-to-date

Rec/Allen/src/RunAllen.h

@@ -33,7 +33,7 @@
 
 class RunAllen final
   : public Gaudi::Functional::MultiTransformerFilter<std::tuple<HostBuffers>(
-      const std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()>& allen_banks,
+      const std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()>& allen_banks,
       const LHCb::ODIN& odin)> {
 public:
   /// Standard constructor
@@ -47,7 +47,7 @@ public:
 
   /// Algorithm execution
   std::tuple<bool, HostBuffers> operator()(
-    const std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()>& allen_banks,
+    const std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()>& allen_banks,
     const LHCb::ODIN& odin) const override;
 
 private:

device/selections/lines/monitoring/include/ODINEventTypeLine.cuh

@@ -32,6 +32,6 @@ namespace odin_event_type_line {
     Property<post_scaler_t> m_post_scaler {this, 0.5f};
     Property<pre_scaler_hash_string_t> m_pre_scaler_hash_string {this, ""};
     Property<post_scaler_hash_string_t> m_post_scaler_hash_string {this, ""};
-    Property<odin_event_type_t> m_odin_event_type {this, static_cast<unsigned short>(LHCb::ODIN::EventTypes::Lumi)};
+    Property<odin_event_type_t> m_odin_event_type {this, static_cast<uint16_t>(LHCb::ODIN::EventTypes::Lumi)};
   };
 } // namespace odin_event_type_line

main/include/TESProvider.h

@@ -37,11 +37,11 @@ public:
    * @param      Array with raw bank content
    * @param      Set with bank types to be used as input for Allen
    */
-  int set_banks(const std::array<std::tuple<std::vector<char>, int>, LHCb::RawBank::types().size()>& transposed_banks)
+  int set_banks(const std::array<std::tuple<std::vector<char>, std::vector<uint16_t>, int>, LHCb::RawBank::types().size()>& transposed_banks)
   {
     // store banks and offsets as BanksAndOffsets object
     for (size_t i = 0; i < transposed_banks.size(); ++i) {
-      auto const& [banks, version] = transposed_banks[i];
+      auto const& [banks, bank_sizes, version] = transposed_banks[i];
 
       if (banks.empty()) continue;
 
@@ -65,12 +65,20 @@ public:
       offsets[0] = 0;
       offsets[1] = banks.size();
 
+      // Bank sizes
+      auto& sizes_offsets = m_sizes[allen_bank_index];
+      // Only 1 event, so a single offset offset is enough. The offset
+      // counts uint16_t and is a uint32_t itself.
+      sizes_offsets[0] = 2;
+      uint16_t* sizes = reinterpret_cast<uint16_t*>(&sizes_offsets[1]);
+      std::copy_n(bank_sizes.begin(), bank_sizes.size(), sizes);
+
       // bank content
       auto data_size = static_cast<span_size_t<char const>>(banks.size());
       gsl::span<char const> b {banks.data(), data_size};
 
       m_banks_and_offsets[allen_bank_index] = {
-        {std::move(b)}, static_cast<std::size_t>(data_size), {offsets.data(), 2u}, version};
+        {std::move(b)}, {offsets.data(), 2u}, static_cast<std::size_t>(data_size), {sizes_offsets.data(), bank_sizes.size() + 1 / 2 + 1}, version};
     }
 
     return 0;
@@ -113,4 +121,5 @@ private:
 
   std::array<BanksAndOffsets, NBankTypes> m_banks_and_offsets;
   std::array<std::array<unsigned int, 2>, NBankTypes> m_offsets;
+  std::array<std::array<unsigned int, (Allen::max_fragments + 1) / 2 + 1>, NBankTypes> m_sizes;
 };