LArRawDataContByteStreamTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "LArByteStream/LArRawDataContByteStreamTool.h"
#include "LArByteStream/LArRodEncoder.h"
#include "LArByteStream/LArRodDecoder.h"
 
#include "ByteStreamCnvSvcBase/FullEventAssembler.h" 
 
#include "LArRawEvent/LArRawChannelContainer.h"
#include "LArRawEvent/LArDigitContainer.h"
#include "LArRawEvent/LArCalibDigitContainer.h"
#include "LArRecConditions/LArCalibLineMapping.h"
#include "LArCabling/LArOnOffIdMapping.h"
 
#include "LArByteStream/LArRodBlockStructure.h"
#include "LArByteStream/LArRodBlockTransparentV0.h"
#include "LArByteStream/LArRodBlockPhysicsV5.h"
#include "LArByteStream/LArRodBlockPhysicsV6.h"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/ThreadLocalContext.h"
 
#include "StoreGate/ReadCondHandle.h"
 
// STL stuff
#include <map> 
 
 
static const InterfaceID IID_ILArRawDataContByteStreamTool
            ("LArRawDataContByteStreamTool", 1, 0);
 
 
const InterfaceID& LArRawDataContByteStreamTool::interfaceID( )
{ return IID_ILArRawDataContByteStreamTool; }
 
// default contructor
 
LArRawDataContByteStreamTool::LArRawDataContByteStreamTool
( const std::string& type, const std::string& name,const IInterface* parent )
  :  AthAlgTool(type,name,parent)
{ declareInterface< LArRawDataContByteStreamTool  >( this );
  declareProperty("DSPRunMode",m_DSPRunMode=4);
  declareProperty("RodBlockVersion",m_RodBlockVersion=0);
  declareProperty("FebNoiseCut",m_nfebsigma=2);
  declareProperty("InitializeForWriting",m_initializeForWriting=false);
  declareProperty("SubDetectorId",m_subDetId=0);
  declareProperty("IncludeDigits",m_includeDigits=false);
  declareProperty("DigitsContainer",m_DigitContName="LArDigitContainer_MC_Thinned");
}
 
LArRawDataContByteStreamTool::~LArRawDataContByteStreamTool() {
}
 
 
StatusCode
LArRawDataContByteStreamTool::initialize()
{
  ATH_CHECK( AthAlgTool::initialize() );
  ATH_MSG_DEBUG ( "Initializing LArRawDataContByteStream" );
 
  ATH_CHECK( m_decoder.retrieve() );
 
  if (m_initializeForWriting) {
   if (m_DSPRunMode == 0) {
     // Obsolete mode 
     ATH_MSG_ERROR ( "LArRodBlockStructure type 0 is obsolete and can't be used any more." );
     return StatusCode::FAILURE;
   }
 
   ATH_CHECK( detStore()->retrieve (m_onlineHelper, "LArOnlineID") );
 
   ATH_MSG_INFO ( "Initialization done for reading and writing" );
 }
  else {
    ATH_MSG_INFO ( "Initialization done for reading only" );
  }
 
  ATH_CHECK( m_caloNoiseKey.initialize (m_initializeForWriting) );
  ATH_CHECK( m_onOffIdMappingKey.initialize (m_initializeForWriting) );
  ATH_CHECK( m_febRodMappingKey.initialize (m_initializeForWriting) );
  ATH_CHECK( m_caloMgrKey.initialize (m_initializeForWriting) );
 
  return StatusCode::SUCCESS;  
}
 
 
StatusCode
LArRawDataContByteStreamTool::finalize()
{
  ATH_CHECK( AthAlgTool::finalize() );
  return StatusCode::SUCCESS;
}
 
StatusCode
LArRawDataContByteStreamTool::WriteLArRawChannels(const LArRawChannelContainer* channelCont, 
                                                  FEA_t& fea) const
{
 if (!m_initializeForWriting) {
   ATH_MSG_ERROR ( "Tool not setup for writing! Use property " 
                   << name()<<".InitializeForWriting" );
   return StatusCode::FAILURE;
 }
 if (!channelCont) {
   ATH_MSG_DEBUG ( "Null pointer passed to WriteLArCalibDigit routine!" );
  return StatusCode::FAILURE;
 }
 
 std::unique_ptr<LArRodBlockStructure> blstruct = makeRodBlockStructure();
 
 if (!blstruct->canSetEnergy()) {
   ATH_MSG_DEBUG ( "This instance of LArRodBlockStructure can't hold LArRawChannels!" );
    return StatusCode::FAILURE;
 }
 FEA_t::RODDATA*  theROD;
 fea.setRodMinorVersion(m_RodBlockVersion);
 fea.setDetEvtType(m_DSPRunMode);
 ATH_MSG_DEBUG ( "Setting Detector Event Type to " << m_DSPRunMode 
                 << "and Minor Version Number to " << m_RodBlockVersion );
 LArRawChannelContainer::const_iterator it = channelCont->begin(); 
 LArRawChannelContainer::const_iterator it_e= channelCont->end(); 
 if ( it==it_e) {
   ATH_MSG_WARNING ( "Attempt to persistify a empty LArDigitContainer to ByteStream" );
   return StatusCode::SUCCESS;
 }
 
 const EventContext& ctx = Gaudi::Hive::currentContext();
 SG::ReadCondHandle<LArOnOffIdMapping> onOffMapping (m_onOffIdMappingKey, ctx);
 SG::ReadCondHandle<LArFebRodMapping> febRodMapping (m_febRodMappingKey, ctx);
 SG::ReadCondHandle<CaloDetDescrManager> caloMgr (m_caloMgrKey, ctx);
 const Hid2RESrcID& hid2re = getHid2RESrcID (**febRodMapping);
 
 std::map<uint32_t, LArRodEncoder> mapEncoder; 
 
 auto getEncoder = [&] (uint32_t reid) -> LArRodEncoder&
                   { return mapEncoder.try_emplace (reid,
                                                    *m_onlineHelper,
                                                    **caloMgr,
                                                    **onOffMapping,
                                                    blstruct.get()).first->second; };
 
 ATH_MSG_DEBUG(" number of LArRawChannel container "<< channelCont->size() );
 for(; it!=it_e; ++it){
     const LArRawChannel& rawChan = *it; 
     HWIdentifier  chid = rawChan.channelID() ; 
     uint32_t reid      = hid2re.getRodID( **febRodMapping, chid ); 
 
     getEncoder(reid).add (&rawChan);
   } 
   // I may want to also include the digits
   if ( m_includeDigits ) {
        const LArDigitContainer* digitCont = nullptr;
    if ( evtStore()->retrieve(digitCont,m_DigitContName).isFailure() ){
          ATH_MSG_ERROR ( "Digits required but not really found" );
    } else {
      if ( blstruct->canIncludeRawData() ){
       LArDigitContainer::const_iterator it_b=digitCont->begin();
       LArDigitContainer::const_iterator it_e=digitCont->end();
       if (it_b==it_e) {
             ATH_MSG_WARNING ( "Attempt to persistify a empty LArDigitContainer to ByteStream" );
       }
       for(; it_b!=it_e; ++it_b){
        const LArDigit* digit = *it_b;
        HWIdentifier  chid = digit->hardwareID() ;
        uint32_t reid      = hid2re.getRodID( **febRodMapping, chid );
        // Lets use anygain for the moment
        getEncoder(reid).add (digit);
           }
      } // End of check whether format allows to include RawData
    } // Finish checking for Digit container in SG
   } // End of check for digits inclusion
 
 SG::ReadCondHandle<CaloNoise> noise (m_caloNoiseKey, ctx);
      
 // Now loop over map and fill all ROD Data Blocks
 std::map<uint32_t,LArRodEncoder>::iterator it_m  =mapEncoder.begin(); 
 std::map<uint32_t,LArRodEncoder>::iterator it_m_e=mapEncoder.end();
 // LArRodEncoder has collected all the channels, now can fill the
 // ROD block data.
 for(; it_m!=it_m_e;++it_m) {
   theROD  = fea.getRodData( (*it_m).first ); 
   ((*it_m).second).fillROD( *theROD,msg(), **noise, m_nfebsigma ) ; 
   // delete ((*it_m).second);
   // ((*it_m).second)=NULL;
 } 
 ATH_MSG_DEBUG ( "Filled " << mapEncoder.size() << " Rod Blocks" );
 return StatusCode::SUCCESS;
}
 
StatusCode
LArRawDataContByteStreamTool::prepareRobIndex(const RawEvent* re,
                                              RobIndex_t& robIndex) const
{
  // This `optimization' leads to disaster if there ever happen to be
  // two adjacent events with identical L1 IDs --- in that case,
  // we'd be using the dangling ROB pointers from the last event.
  // We should generally come through here only once per event anyway.
  ATH_MSG_DEBUG( "Converting event (from ByteStream)" );
 
  if (!re) {
    ATH_MSG_ERROR ( "RawEvent passed to 'convert'-function is a null pointer!" );
    return StatusCode::FAILURE;
  }
 
  if (!m_decoder->check_valid (re, msg())) return StatusCode::FAILURE;
 
  ATH_MSG_VERBOSE ( "Full Event:" );
  ATH_MSG_VERBOSE ( MSG::hex << "Full source ID: " << re->source_id() << MSG::dec );
  ATH_MSG_VERBOSE ("Fragment size in words: " << re->fragment_size_word() );
 
  // Need to clear up or it will accumulate
  robIndex.clear();
  eformat::helper::build_toc(*re, robIndex );
  if ( robIndex.empty() ) { // This is a problem
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 

std::unique_ptr<LArRodBlockStructure>
LArRawDataContByteStreamTool::makeRodBlockStructure() const
{
  switch(m_DSPRunMode) {
  case 0:  // Obsolete; shouldn't get here.
    std::abort();
 
  case 2:  //Transparent mode, DSP just copies FEB-data                                            
    ATH_MSG_DEBUG ( "Set Rod Block Type to LArRodBlockTransparent (#2)" );
    return std::make_unique<LArRodBlockTransparentV0<LArRodBlockHeaderTransparentV0> >(this->msgSvc().get());
    break;
 
  case 4: //Physics assembly mode
    if ( m_RodBlockVersion == 10 ){
      ATH_MSG_DEBUG ( "Set Rod Block Type to LArRodBlockPhysics (#5)" );
      return std::make_unique<LArRodBlockPhysicsV5>(this->msgSvc().get());
    }
    else if ( m_RodBlockVersion == 12 ){
      ATH_MSG_DEBUG ( "Set Rod Block Type to LArRodBlockPhysics (#6)" );
      return std::make_unique<LArRodBlockPhysicsV6>(this->msgSvc().get());
    }
    else {
      ATH_MSG_ERROR ( "Unsupported Rod block version " << m_RodBlockVersion << " for physics assembly mode (#4)" );
      std::abort();
    }
    break;
 
  default:
    ATH_MSG_ERROR ( "DSP runmode " << m_DSPRunMode << " is unknown." );
    std::abort();
  }
}
 
 
const Hid2RESrcID&
LArRawDataContByteStreamTool::getHid2RESrcID (const LArFebRodMapping& rodMapping) const
{
  if (!m_hid2re) {
    auto hid2re = std::make_unique<Hid2RESrcID>();
    if (hid2re->initialize (rodMapping).isFailure()) {
      std::abort();
    }
    m_hid2re.set (std::move (hid2re));
  }
  return *m_hid2re.get();
}