LArRawDataContByteStreamTool.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARBYTESTREAM_LARRAWDATACONTBYTESTREAMTOOL_H
#define LARBYTESTREAM_LARRAWDATACONTBYTESTREAMTOOL_H
 
#include <stdint.h>
#include "AthenaBaseComps/AthAlgTool.h"
#include "LArByteStream/Hid2RESrcID.h"
#include "LArByteStream/RodRobIdMap.h"
#include "LArCabling/LArOnOffIdMapping.h"
#include "LArRecConditions/LArFebRodMapping.h"
#include "ByteStreamCnvSvcBase/FullEventAssembler.h" 
#include "ByteStreamData/RawEvent.h" 
#include "LArByteStream/LArRodDecoder.h"
 
#include "CaloIdentifier/CaloGain.h"
#include "CaloConditions/CaloNoise.h"
#include "StoreGate/ReadCondHandleKey.h"
#include "CaloDetDescr/CaloDetDescrManager.h"
#include "CxxUtils/CachedUniquePtr.h"
 
#include "LArRawEvent/LArFebHeaderContainer.h"
// Map of ROBs need this
#include "eformat/index.h"
 
class LArRawChannelContainer; 
class LArDigitContainer;
class IByteStreamEventAccess;
 
class LArRawDataContByteStreamTool: public AthAlgTool {
public:
  using FEA_t = FullEventAssembler<RodRobIdMap>;
 
   LArRawDataContByteStreamTool( const std::string& type, const std::string& name,
                                 const IInterface* parent ) ;
 
  virtual ~LArRawDataContByteStreamTool() ;
 
  static const InterfaceID& interfaceID( ) ;
 
  virtual StatusCode initialize() override;
  virtual StatusCode finalize() override;
 
  template <class COLLECTION, typename ...ARGS >
  StatusCode convert(const RawEvent* re,
                     COLLECTION* digit_cont,
                     CaloGain::CaloGain gain,
                     ARGS&&... args) const;
 
  StatusCode WriteLArDigits(const LArDigitContainer* digit_cont,
                            FEA_t& fea) const;
 
  StatusCode WriteLArCalibDigits(const LArCalibDigitContainer* digit_cont,
                                 FEA_t& fea) const;
 
  StatusCode WriteLArRawChannels(const LArRawChannelContainer* CannelCont,
                                 FEA_t& fea) const;
 
private: 
  using RobIndex_t = std::map<eformat::SubDetectorGroup, std::vector<const uint32_t*> >;
 
  StatusCode prepareRobIndex (const RawEvent* event, RobIndex_t& robIndex) const;
 
  std::unique_ptr<LArRodBlockStructure> makeRodBlockStructure() const;
 
  //StatusCode prepareWriting();
  template <class COLLECTION >
    bool checkGainConsistency(const COLLECTION* coll) const;
 
  const Hid2RESrcID& getHid2RESrcID (const LArFebRodMapping& rodMapping) const;
 
  CxxUtils::CachedUniquePtr<Hid2RESrcID> m_hid2re;       
  PublicToolHandle<LArRodDecoder> m_decoder
    { this, "LArRodDecoder", "LArRodDecoder", "LArRodDecoder" };
 
  unsigned m_DSPRunMode;
 
  unsigned short m_RodBlockVersion;
 
  bool m_initializeForWriting;
  uint16_t m_subDetId;
  double m_nfebsigma;
  // want to process digits together with RawChannel
  bool m_includeDigits;
  // Name of Digit container to retrieve
  std::string m_DigitContName;
 
  const LArOnlineID*    m_onlineHelper = nullptr;
 
  SG::ReadCondHandleKey<CaloNoise> m_caloNoiseKey
  { this, "CaloNoiseKey", "totalNoise", "" };
 
  SG::ReadCondHandleKey<LArOnOffIdMapping> m_onOffIdMappingKey
  { this, "OnOffIdMappingKey", "LArOnOffIdMap", "LArOnOffIdMap" };
 
  SG::ReadCondHandleKey<LArFebRodMapping> m_febRodMappingKey
  { this, "FebRodMappingKey", "LArFebRodMap", "LArFebRodMap" };
 
  SG::ReadCondHandleKey<CaloDetDescrManager> m_caloMgrKey
  { this, "CaloDetDescrManager", "CaloDetDescrManager", "SG Key for CaloDetDescrManager in the Condition Store" };
};
 
 
#include "LArByteStream/LArRawDataContByteStreamTool.icc" 
 
#endif