TRT_RodDecoder.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRT_RAWDATABYTESTREAM_TRT_RODDECODER_H
#define TRT_RAWDATABYTESTREAM_TRT_RODDECODER_H
 
 
/*
 * Base class
 */
#include "AthenaBaseComps/AthAlgTool.h"
 
/*
 * Interface class for this Tool
 */
#include "TRT_RawDataByteStreamCnv/ITRT_RodDecoder.h"
 
/*
 * TRT Tools we use
 */
#include "TRT_Cabling/ITRT_CablingSvc.h"
 
/*
 * Framework Headers
 *   Service & Tool Handles
 */
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ToolHandle.h"
#include "GaudiKernel/ContextSpecificPtr.h"
#include "GaudiKernel/ICondSvc.h"
#include "AthenaPoolUtilities/CondAttrListCollection.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "CxxUtils/CachedUniquePtr.h"
#include "Identifier/IdContext.h"
 
/*
 * For cache
 */
#include "AthenaKernel/SlotSpecificObj.h"
#include "CxxUtils/checker_macros.h"
 
/*
 * STL
 */
#include <atomic>
#include <map>
#include <vector>
#include <cstdint>
#include <memory>
 
class TRT_ID;
 
// the tool to decode a ROB frament
 
class TRT_RodDecoder : public extends<AthAlgTool, ITRT_RodDecoder>
{
public:
  TRT_RodDecoder(const std::string& type, const std::string& name,
                 const IInterface* parent ) ;
  virtual ~TRT_RodDecoder();
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;

  virtual StatusCode fillCollection ( const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment* robFrag,
                      TRT_RDO_Container* rdoIdc,
                      TRT_BSErrContainer* bserr,
              DataPool<TRT_LoLumRawData>* dataItemsPool,
              const EventContext& ctx,
                      const std::vector<IdentifierHash>* vecHash = 0) const override;
 
 
 private:
 
   ServiceHandle<ITRT_CablingSvc>   m_CablingSvc;
 
   /*
    * Do we look for Front-End Errors at all?
    */
   bool m_recordBSErrors{};
 
   /*
    * Do we look for these types of Front-End Errors?
    */
   bool m_lookAtSidErrors{};
   bool m_lookAtErrorErrors{};
   bool m_lookAtL1idErrors{};
   bool m_lookAtBcidErrors{};
   bool m_lookAtMissingErrors{};
 
   bool m_loadCompressTableFile{};
   bool m_loadCompressTableDB{};
   std::vector<int> m_LoadCompressTableVersions;
   const int m_maxCompressionVersion{};
   int m_forceRodVersion{};
 
   const TRT_ID*               m_trt_id{};
   IdContext                   m_straw_layer_context{};
 
   BooleanProperty m_TB04_RawData;   // true to create TRT_TB04_RawData RDOs
   BooleanProperty m_LoLumRawData;   // true to create TRT_LoLumRawData RDOs
 
   bool m_eventTypeIsSim{};            // look at first event to decide if RODBlockVersion
                                    // is incorrect.
 
   uint32_t m_escape_marker{};           // Straw word that means escaped literal
 
   bool m_sortCollections{};         // sort collections by identifiers if required
 
#define CTABLE_FC_LENGTH 33
#define CTABLE_LI_LENGTH 33
   struct t_CompressTable{
     // The TableVersion is a compression scheme.
     // There are presently 6 TableVersions for the different run periods of ATLAS.
     // Any IoV of /TRT/onl/ROD/Compress has one (and only one) of these as an attribute.
     // The code takes advantage of this and caches locally any TableVersion that is encountered
     int m_TableVersion{};
     int m_firstcode[CTABLE_FC_LENGTH]{};
     int m_lengths_integral[CTABLE_FC_LENGTH]{};    // ..[i] = Sum(numl[0,i-1])
     std::unique_ptr<unsigned int[]> m_syms;              // Array of symbols (straw data words)
     int m_Nsymbols{};
   } ;
 
   std::vector<CxxUtils::CachedUniquePtr<t_CompressTable> > m_CompressionTables;
 
   mutable std::atomic<uint32_t> m_Nrdos;              // Number of RDOs created
 
   mutable std::atomic<int> m_err_count_fillCollection{0};
   mutable std::atomic<int> m_err_count_int_fillMinimalCompress{0};
   mutable std::atomic<int> m_err_count_int_fillFullCompress{0};
 
   // This replaces the IOVCALLBACK
   SG::ReadCondHandleKey<CondAttrListCollection> m_CompressKey{this,"keyName","/TRT/Onl/ROD/Compress","in-key"};
   StatusCode update(const EventContext& ctx) const;

private:
 StatusCode int_fillExpanded(
     const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment* robFrag,
     TRT_RDO_Container* rodIdc, DataPool<TRT_LoLumRawData>* dataItemsPool,
     const std::vector<IdentifierHash>* vecHash = 0) const;
 
 StatusCode int_fillMinimalCompress(
     const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment* robFrag,
     TRT_RDO_Container* rdoIdo, DataPool<TRT_LoLumRawData>* dataItemsPool,
     const std::vector<IdentifierHash>* vecHash = 0) const;
 
 StatusCode int_fillFullCompress(
     const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment* robFrag,
     TRT_RDO_Container* rdoIdo, DataPool<TRT_LoLumRawData>* dataItemsPool,
     const t_CompressTable& Ctable,
     const std::vector<IdentifierHash>* vecHash = 0) const;
 
 StatusCode ReadCompressTableFile(const std::string& TableFilename);
 StatusCode ReadCompressTableDB(std::string Tag);
 
 mutable SG::SlotSpecificObj<std::atomic<EventContext::ContextEvt_t> >
     m_lastPrint ATLAS_THREAD_SAFE;
 
 mutable std::atomic<unsigned int> m_skip{};
 mutable std::atomic<unsigned int> m_accept{};
};
 
#endif