LArABBADecoder.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "LArByteStream/LArABBADecoder.h"
#include "LArByteStream/ABBAMapping.h"
 
static const InterfaceID IID_ILArABBADecoder("LArABBADecoder", 1, 0);
 
 
using namespace OFFLINE_FRAGMENTS_NAMESPACE;
 
LArABBADecoder::LArABBADecoder(const std::string& type, const std::string& name,
                   const IInterface* parent ) 
  : AthAlgTool(type,name,parent) 
{
  declareInterface< LArABBADecoder  >( this );
}
 
const InterfaceID& LArABBADecoder::interfaceID( )
{ return IID_ILArABBADecoder;  }
 
 
 
LArABBADecoder::~LArABBADecoder() {}
 
 
StatusCode LArABBADecoder::initialize() {
  return StatusCode::SUCCESS;
}
 
StatusCode LArABBADecoder::finalize() {
  return StatusCode::SUCCESS;
}
 
StatusCode LArABBADecoder::convert(const RawEvent* re, LArDigitContainer* coll) const
{
  bool ret=false;
  // Check fragment validity:
  try {
    ret=re->check();
  } 
  catch (eformat::Issue& ex) {
    ATH_MSG_WARNING( "Exception while checking eformat fragment validity: " << ex.what() ); 
    ret=false;
  }
  if (!ret) {
    ATH_MSG_ERROR( "Got invalid RawEvent fragment" );
    return StatusCode::FAILURE;
  }
  
  //Build TOC
  std::map<eformat::SubDetectorGroup, std::vector<const uint32_t*> > robIndex;
  eformat::helper::build_toc(*re, robIndex );
  std::map<eformat::SubDetectorGroup, std::vector<const uint32_t*> >::const_iterator robIt = robIndex.find(eformat::LAR);
  if (robIt!=robIndex.end()) {
    const std::vector<const uint32_t*>& robs = robIt->second;
    for (const uint32_t* pRob :robs) {
      try {
        ROBFragment robFrag(pRob);
        fillCollection(&robFrag,coll);
      }
      catch (eformat::Issue& ex) {
        ATH_MSG_WARNING ( " exception thrown by ROBFragment, badly corrupted event. Abort decoding " );
        coll->clear();
        break;
      }
    }//end loop over robs
  }//end if got LAr-RODs   
  return StatusCode::SUCCESS;
}
 
 
void LArABBADecoder::fillCollection(const ROBFragment* robFrag, LArDigitContainer* coll) const
{
  const CaloGain::CaloGain dummyGain=CaloGain::LARHIGHGAIN;
  LArDigit * scDigit=0 ;
 
  //FIXME: Check validity
  uint32_t nData = robFrag->rod_ndata(); 
  const uint32_t* p=robFrag->rod_data();
  if (nData < 3) {
    ATH_MSG_WARNING ( "Error reading bytestream event: "
                      << "Empty ROD block (less than 3 words) for source ID " << robFrag->rod_source_id() );
    return;
  }
  else
    robFrag->rod_source_id();
 
  unsigned int n = robFrag->payload_size_word();
 
  std::vector<std::string> string;
  int x=0x0;
  int nsamples = p[0];
  for(unsigned int s=1;s<n-13;s+=6) {
    std::string ss;
    for (unsigned int k=0;k<6;++k){
      x = p[s+k];
      std::ostringstream oss;
      oss << std::hex << x;
      if (oss.str().size() == 7){
        ss.append("0");
      }
      ss += oss.str();
    }
    string.push_back(std::move(ss));
  }
 
  constexpr int nFibers = 20;
  constexpr int nchannels = 8;
  constexpr int Nabbachannels = nFibers * nchannels;
 
  constexpr int fiberSeq[16] = {0,0,1,1,0,0,1,1,0,0,1,1,0,0,1,1};
  constexpr int adcSeq[16] =   {1,0,1,0,3,2,3,2,5,4,5,4,7,6,7,6};
 
  std::vector< std::vector< std::vector<int> > > abbasamples;
  abbasamples.resize(nFibers);
 
  std::vector<std::vector<short>> abba_channel_samples;
  abba_channel_samples.resize(Nabbachannels);
 
  for (int fib=0;fib < nFibers; ++fib){
    abbasamples[fib].resize(nchannels);
    for (int ch = 0; ch < nchannels; ++ch){
      abbasamples[fib][ch].resize(nsamples);
      int Nchannel = fib*8 + ch;
      abba_channel_samples[Nchannel].resize(nsamples);
    }
  }
    
  for (int fib=0;fib < nFibers; fib+=2){
    for (int sam=0; sam < nsamples; sam++){
      int zx = sam + (fib/2)*nsamples;
      const std::string &wx = string[zx];
      int k = 0;
      for (int m = 0; m < 16; ++m){ //16 size of fiberSeq array
        int fiber_number = fiberSeq[m];
        int adc_number = adcSeq[m];
        int idx = k*3;
        std::stringstream ss;
        char mysample[3];
        for (int j = idx; j < idx+3; ++j){
          int i = j%3;
          mysample[i] = wx[j];
        }
        ss << mysample;
        short mysample_int;
        ss >> std::hex >> mysample_int;
        int fb = fiber_number+fib;
        int ch = adc_number;
        int abbachannel = fb*8+ch;
        k++;
        abbasamples[fb][ch][sam] = mysample_int;
        abba_channel_samples[abbachannel][sam] = mysample_int;
      }
    }
  }
 
  std::map<int, HWIdentifier> abba_mapping;
 
 
  int iphi = 0;
  switch (robFrag->rod_source_id())
  {
  case 0x410511:
    iphi=19;
    break;
  case 0x410512:
    iphi=18;
    break;
  case 0x410521:
    iphi=20;
    break;
  case 0x410522:
    iphi=21;
    break;
 
  default:
    ATH_MSG_ERROR("ROD_source_id not found");
  }
 
 
  ABBAMapping::fill(&abba_mapping, iphi, msg());
 
 
  for (std::size_t index_abba_channel_samples = 0; index_abba_channel_samples < abba_channel_samples.size(); ++index_abba_channel_samples) {
    auto abba_mapping_search = abba_mapping.find(index_abba_channel_samples);
    if (abba_mapping_search == abba_mapping.end()) {
      ATH_MSG_WARNING("No mapping for index_abba_channel_samples: "<<std::dec<<index_abba_channel_samples);
      continue;
    }
    
    HWIdentifier channelID = (*abba_mapping_search).second;
    std::vector<short> adcValues = abba_channel_samples[index_abba_channel_samples];
    scDigit=new LArDigit(channelID,dummyGain,std::move(adcValues));
 
    coll->push_back(scDigit);
  }
 
  abbasamples.clear();
}