CpByteStreamV2Tool.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRIGT1CALOBYTESTREAM_CPBYTESTREAMV2TOOL_H
#define TRIGT1CALOBYTESTREAM_CPBYTESTREAMV2TOOL_H
 
#include <stdint.h>
 
#include <map>
#include <string>
#include <vector>
 
#include "TrigT1CaloUtils/TriggerTowerKey.h"
#include "L1CaloSrcIdMap.h"
#include "AthenaBaseComps/AthAlgTool.h"
#include "ByteStreamCnvSvcBase/IROBDataProviderSvc.h"
#include "ByteStreamCnvSvcBase/IByteStreamCnvSvc.h"
#include "ByteStreamData/RawEvent.h"
#include "AthContainers/DataVector.h"
#include "eformat/SourceIdentifier.h"
#include "GaudiKernel/ToolHandle.h"
 
class IInterface;
class InterfaceID;
class StatusCode;
 
template <typename> class FullEventAssembler;
 
namespace LVL1 {
  class CMXCPHits;
  class CMXCPTob;
  class CPMTower;
  class CPBSCollectionV2;
  class IL1CaloMappingTool;
  class TriggerTowerKey;
}
 
namespace LVL1BS {
 
class CmxCpSubBlock;
class CpmSubBlockV2;
class L1CaloErrorByteStreamTool;
class L1CaloSrcIdMap;

 
class CpByteStreamV2Tool : public AthAlgTool {
 
 public:
   CpByteStreamV2Tool(const std::string& type, const std::string& name,
                                               const IInterface* parent);
   virtual ~CpByteStreamV2Tool();

   static const InterfaceID& interfaceID();
 
   virtual StatusCode initialize() override;

   StatusCode convert(const std::string& sgKey, DataVector<LVL1::CPMTower>* ttCollection) const;
   StatusCode convert(const std::string& sgKey,
                      const IROBDataProviderSvc::VROBFRAG& robFrags,
                      DataVector<LVL1::CPMTower>* ttCollection) const;
   StatusCode convert(const std::string& sgKey,
                      DataVector<LVL1::CMXCPTob>* tobCollection) const;
   StatusCode convert(const std::string& sgKey,
                      const IROBDataProviderSvc::VROBFRAG& robFrags,
                      DataVector<LVL1::CMXCPTob>* tobCollection) const;
   StatusCode convert(const std::string& sgKey,
                      DataVector<LVL1::CMXCPHits>* hitCollection) const;
   StatusCode convert(const std::string& sgKey,
                      const IROBDataProviderSvc::VROBFRAG& robFrags,
                      DataVector<LVL1::CMXCPHits>* hitCollection) const;

   StatusCode convert(const LVL1::CPBSCollectionV2* cp) const;

   const std::vector<uint32_t>& sourceIDs() const;
 
 private:
   // Need option to disable dependency on offline ByteStreamCnvSvc to be able to run
   // decoding in online HLT framework (which uses TrigByteStreamCnvSvc)
   Gaudi::Property<bool> m_enableEncoding{
     this, "enableEncoding", true, "Enable conversion from RDO to ByteStream"};
   SmartIF<IByteStreamCnvSvc> m_byteStreamCnvSvc;
 
   struct LocalData
   {
     int coreOverlap = 0;
     unsigned int rodErr = 0;
     std::vector<int> energyVec;
     std::vector<int> isolVec;
     std::vector<int> errorVec;
     std::vector<unsigned int> presenceMapVec;
     std::vector<unsigned int> hitsVec0;
     std::vector<unsigned int> hitsVec1;
     std::vector<int> errVec0;
     std::vector<int> errVec1;
     std::vector<int> emVec;
     std::vector<int> hadVec;
     std::vector<int> emErrVec;
     std::vector<int> hadErrVec;
     LVL1::TriggerTowerKey towerKey;
   };
 
   enum CollectionType { CPM_TOWERS, CMX_CP_TOBS, CMX_CP_HITS };
 
   typedef DataVector<LVL1::CPMTower>                    CpmTowerCollection;
   typedef DataVector<LVL1::CMXCPTob>                    CmxCpTobCollection;
   typedef DataVector<LVL1::CMXCPHits>                   CmxCpHitsCollection;
   typedef std::map<unsigned int, LVL1::CPMTower*>       CpmTowerMap;
   typedef std::map<unsigned int, const LVL1::CPMTower*> ConstCpmTowerMap;
   typedef std::map<int, LVL1::CMXCPTob*>                CmxCpTobMap;
   typedef std::map<int, const LVL1::CMXCPTob*>          ConstCmxCpTobMap;
   typedef std::map<int, LVL1::CMXCPHits*>               CmxCpHitsMap;
   typedef std::map<int, const LVL1::CMXCPHits*>         ConstCmxCpHitsMap;
   typedef IROBDataProviderSvc::VROBFRAG::const_iterator ROBIterator;
   typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType      ROBPointer;
   typedef OFFLINE_FRAGMENTS_NAMESPACE::PointerType      RODPointer;
 
   struct CpByteStreamToolData
   {
     CpByteStreamToolData (const CollectionType collection)
       : m_collection(collection){}
     const CollectionType m_collection;
   };
   struct CpmTowerData : public CpByteStreamToolData
   {
     CpmTowerData (CpmTowerCollection* const ttCollection)
       : CpByteStreamToolData (CPM_TOWERS), m_ttCollection (ttCollection) {}
     CpmTowerCollection* const m_ttCollection;
     CpmTowerMap  m_ttMap;
   };
   struct CmxCpTobData : public CpByteStreamToolData
   {
     CmxCpTobData (CmxCpTobCollection* const tobCollection)
       : CpByteStreamToolData (CMX_CP_TOBS), m_tobCollection (tobCollection) {}
     CmxCpTobCollection* const m_tobCollection;
     CmxCpTobMap  m_tobMap;
   };
   struct CmxCpHitsData : public CpByteStreamToolData
   {
     CmxCpHitsData (CmxCpHitsCollection* const hitCollection)
       : CpByteStreamToolData (CMX_CP_HITS), m_hitCollection (hitCollection) {}
     CmxCpHitsCollection* const m_hitCollection;
     CmxCpHitsMap m_hitsMap;
   };

   std::vector<uint32_t> makeSourceIDs() const;

   StatusCode convertBs(const std::string& sgKey,
                        const IROBDataProviderSvc::VROBFRAG& robFrags,
                        CpByteStreamToolData& data) const;
   void decodeCmxCp(CmxCpSubBlock* subBlock, int trigCpm, CpByteStreamToolData& data,
                    LocalData& ld) const;
   void decodeCpm(CpmSubBlockV2* subBlock, int trigCpm, CpmTowerData& data,
                  LocalData& ld) const;

   const LVL1::CPMTower*  findCpmTower(unsigned int key,
                                       const ConstCpmTowerMap& ttMap) const;
   LVL1::CPMTower*  findCpmTower(const CpmTowerData& data, unsigned int key) const;
   const LVL1::CMXCPTob*  findCmxCpTob(int key,
                                       const ConstCmxCpTobMap& tobMap) const;
   LVL1::CMXCPTob*  findCmxCpTob(const CmxCpTobData& data, int key) const;
   const LVL1::CMXCPHits* findCmxCpHits(int key,
                                        const ConstCmxCpHitsMap& hitsMap) const;
   LVL1::CMXCPHits* findCmxCpHits(const CmxCpHitsData& data, int key) const;

   void setupCpmTowerMap(const CpmTowerCollection* ttCollection,
                         ConstCpmTowerMap& ttMap,
                         LVL1::TriggerTowerKey& towerKey) const;
   void setupCmxCpTobMap(const CmxCpTobCollection* tobCollection,
                         ConstCmxCpTobMap& tobMap) const;
   void setupCmxCpHitsMap(const CmxCpHitsCollection* hitCollection,
                          ConstCmxCpHitsMap& hitsMap) const;

   int tobKey(int crate, int cmx, int cpm, int chip, int loc) const;
   int hitsKey(int crate, int cmx, int source) const;

   bool slinkSlices(int crate, int module, int modulesPerSlink,
                    int& timeslices, int& trigJem,
                    const ConstCpmTowerMap& ttMap,
                    const ConstCmxCpTobMap& tobMap,
                    const ConstCmxCpHitsMap& hitsMap,
                    LVL1::TriggerTowerKey& towerKey) const;

   ToolHandle<LVL1::IL1CaloMappingTool> m_cpmMaps;
   ToolHandle<LVL1BS::L1CaloErrorByteStreamTool> m_errorTool;
   ServiceHandle<IROBDataProviderSvc> m_robDataProvider;
   int m_crateOffsetHw;
   int m_crateOffsetSw;
   int m_version;
   int m_dataFormat;
   const int m_channels;
   int m_crates;
   const int m_modules;
   const int m_cmxs;
   const int m_maxTobs;
   const int m_chips;
   const int m_locs;
   int m_slinks;
   int m_dfltSlices;
   int m_forceSlices;
   int m_crateMin;
   int m_crateMax;
   const eformat::SubDetector m_subDetector;
   const L1CaloSrcIdMap m_srcIdMap;
   std::vector<uint32_t> m_sourceIDsProp;
};
 
} // end namespace
 
#endif