Allen RICH decoding

Rich/RichFutureDAQ/include/RichFutureDAQ/RichPDMDBDecodeMapping.h

@@ -54,11 +54,16 @@ namespace Gaudi {
 
 namespace Rich::Future::DAQ {
 
+  namespace Allen {
+    class PDMDBDecodeMapping;
+  }
+
   // overloads for vectors etc.
   using GaudiUtils::operator<<;
 
   /// Helper class for RICH PDMDB readout mapping
   class PDMDBDecodeMapping final {
+    friend class Allen::PDMDBDecodeMapping;
 
   private:
     // types
@@ -291,4 +296,26 @@ namespace Rich::Future::DAQ {
     Rich::AllocateCount<PDMDBDecodeMapping> m_track_instances;
   };
 
+  // Convertor to Allen data format, suitable for GPU processing
+  namespace Allen {
+    class PDMDBDecodeMapping final {
+      using RTypeRichData = Rich::Future::DAQ::PDMDBDecodeMapping::RTypeRichData;
+      using PDMData       = Rich::Future::DAQ::PDMDBDecodeMapping::PDMData;
+
+      RTypeRichData m_pdmDataR;
+      PDMData       m_pdmDataH;
+      bool          m_isInitialised{false};
+      int           m_mappingVer{-1};
+
+    public:
+      PDMDBDecodeMapping() = default;
+
+      PDMDBDecodeMapping( const Rich::Future::DAQ::PDMDBDecodeMapping& mapping )
+          : m_pdmDataR( mapping.m_pdmDataR )
+          , m_pdmDataH( mapping.m_pdmDataH )
+          , m_isInitialised( mapping.isInitialised() )
+          , m_mappingVer( mapping.version() ) {}
+    };
+  } // namespace Allen
+
 } // namespace Rich::Future::DAQ

Rich/RichFutureDAQ/include/RichFutureDAQ/RichTel40CableMapping.h

@@ -56,11 +56,16 @@ namespace Gaudi {
 
 namespace Rich::Future::DAQ {
 
+  namespace Allen {
+    class Tel40CableMapping;
+  }
+
   // overloads for vectors etc.
   using GaudiUtils::operator<<;
 
   /// Helper class for RICH PMT data format encoding
   class Tel40CableMapping final {
+    friend class Allen::Tel40CableMapping;
 
   public:
     /// Local struct to hold conditions
@@ -330,4 +335,91 @@ namespace Rich::Future::DAQ {
     Rich::AllocateCount<Tel40CableMapping> m_track_instances;
   };
 
+  // Convertor to Allen data format, suitable for GPU processing
+  namespace Allen {
+    class Tel40CableMapping final {
+    public:
+      class Tel40LinkData final {
+      public:
+        LHCb::RichSmartID::KeyType      smartID;
+        Rich::DAQ::PDModuleNumber::Type moduleNum{};
+        Rich::DAQ::SourceID::Type       sourceID{};
+        Rich::DAQ::Tel40Connector::Type connector{};
+        Rich::DAQ::PDMDBID::Type        pdmdbNum{};
+        Rich::DAQ::PDMDBFrame::Type     linkNum{};
+        bool                            isHType{false};
+        bool                            isActive{false};
+
+      public:
+        Tel40LinkData() = default;
+        /// Constructor from a Rich::Future::DAQ::Tel40LinkData
+        Tel40LinkData( const Rich::Future::DAQ::Tel40CableMapping::Tel40LinkData& data )
+            : smartID( data.smartID )
+            , moduleNum( data.moduleNum.data() )
+            , sourceID( data.sourceID.data() )
+            , connector( data.connector.data() )
+            , pdmdbNum( data.pdmdbNum.data() )
+            , linkNum( data.linkNum.data() )
+            , isHType( data.isHType )
+            , isActive( data.isActive ) {}
+      };
+
+      Tel40CableMapping( const Rich::Future::DAQ::Tel40CableMapping& data )
+          : m_isInitialised( data.isInitialised() ), m_mappingVer( data.version() ) {
+        // Initialize m_tel40ConnMeta with no active links
+        for ( auto& i : m_tel40ConnMeta ) {
+          for ( auto& j : i ) {
+            for ( auto& k : j ) { k = Tel40MetaData{0, 0}; }
+          }
+        }
+
+        if ( data.isInitialised() ) {
+          for ( unsigned int i = 0; i < data.m_tel40ModuleData.size(); ++i ) {
+            for ( unsigned int j = 0; j < data.m_tel40ModuleData[i].size(); ++j ) {
+              for ( unsigned int k = 0; k < data.m_tel40ModuleData[i][j].size(); ++k ) {
+                m_tel40ModuleData[i][j][k] = data.m_tel40ModuleData.at( i ).at( j ).at( k );
+              }
+            }
+          }
+
+          for ( unsigned int i = 0; i < data.m_tel40ConnData.size(); ++i ) {
+            for ( unsigned int j = 0; j < data.m_tel40ConnData[i].size(); ++j ) {
+              for ( unsigned int k = 0; k < data.m_tel40ConnData[i][j].size(); ++k ) {
+                const auto& link_data = data.m_tel40ConnData.at( i ).at( j ).at( k );
+                m_tel40ConnMeta[i][j][k] =
+                    Tel40MetaData{static_cast<uint32_t>( link_data.nActiveLinks ), link_data.hasInactiveLinks};
+                for ( unsigned int l = 0; l < link_data.size(); ++l ) {
+                  m_tel40ConnData[i][j][k][l] = link_data.at( l );
+                }
+              }
+            }
+          }
+        }
+      }
+
+      class Tel40MetaData final {
+      public:
+        std::uint32_t nActiveLinks     = 0;
+        bool          hasInactiveLinks = false;
+      };
+
+      static constexpr const std::size_t MaxLinksPerPDMDB = Rich::Future::DAQ::Tel40CableMapping::MaxLinksPerPDMDB;
+      static constexpr const std::size_t PDMDBPerModule   = Rich::Future::DAQ::Tel40CableMapping::PDMDBPerModule;
+      using PDMDBLinkData                                 = std::array<Tel40LinkData, MaxLinksPerPDMDB>;
+      using PDMDBData                                     = std::array<PDMDBLinkData, PDMDBPerModule>;
+      using ModuleTel40Data = std::array<PDMDBData, LHCb::RichSmartID::MaPMT::TotalModules>;
+
+      // TODO: The 164 limit should be studied
+      using Tel40SourceIDs   = DetectorArray<PanelArray<std::array<std::array<Tel40LinkData, 24>, 164>>>;
+      using Tel40SourceMetas = DetectorArray<PanelArray<std::array<Tel40MetaData, 164>>>;
+
+    private:
+      Tel40SourceIDs   m_tel40ConnData;
+      Tel40SourceMetas m_tel40ConnMeta;
+      ModuleTel40Data  m_tel40ModuleData;
+      bool             m_isInitialised{false};
+      int              m_mappingVer{-1};
+    };
+
+  } // namespace Allen
 } // namespace Rich::Future::DAQ