LArRodBlockPhysicsV0.h

Go to the documentation of this file.

//Dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARBYTESTREAM_LARRODBLOCKPYSICSV0_H
#define LARBYTESTREAM_LARRODBLOCKPYSICSV0_H

 
  
 
#include <stdint.h>
#include <vector>
#include "LArByteStream/LArRodBlockStructure.h"
#include "StoreGate/StoreGateSvc.h"
#include "AthenaKernel/getMessageSvc.h"
 
 
#ifdef  LARBSDBGOUTPUT
#define LARBSDBG(text) m_logstr<<MSG::DEBUG<<text<<endmsg
#else
#define LARBSDBG(text)
#endif
 
class LArRodBlockPhysicsV0 : public LArRodBlockStructure
{
public:
  // constructor
  LArRodBlockPhysicsV0(IMessageSvc* msgSvc);
 
protected:
  // ----------------- Header words indexes -----------------
  enum {
    NWTot,
    NWTot_h,
    FEBID,
    FEBID_h,
    FEB_SN,
    FEB_SN_h,
    LowEBlkOffset,
    HighEBlkOffset,
    RawDataBlkOffset,
    NGainNSamples,          //Elements below this are not used by the converter
    Status1,
    Status2,
    BCID,
    EventID,
    RADD1,
    RADD2,                 //Could have more RADD's in real data
    endtag
  };
 
 public:
  static std::string BlockType() { return std::string("RodBlockPhysicsV0");}
  // ----------------- Encoding methods -----------------
  // Never to be used while decoding!
  virtual void initializeFragment(std::vector<uint32_t>& fragment);
  virtual void initializeFEB(const uint32_t id);
  virtual void setNumberOfSamples(const uint8_t n);
  virtual void setNumberOfGains(const uint8_t n);
  virtual void setNextEnergy(const int channel, const int32_t energy, const int32_t time, const int32_t quality, const uint32_t gain);
  virtual void setRawData(const int channel, const std::vector<short>& samples, const uint32_t gain);
  virtual void finalizeFEB();
  // build full ROD fragment
  virtual void concatinateFEBs();
  //Function to sort RawData Container before encoding:
  using LArRodBlockStructure::sortDataVector;  // avoid warnings.
  virtual void sortDataVector(std::vector<const LArRawChannel*>& );
  virtual void sortDataVector( std::vector<const LArDigit*>& );
  // declare capabilities of this Rod Block Structure
  virtual bool canSetEnergy() { return true;}
  virtual bool canSetRawData() {return true;}
  //Ordering relation for channels & digits
  template<class RAWDATA>
  bool operator () (const RAWDATA* ch1, const RAWDATA* ch2) const;
 
  // ----------------- Decoding methods -----------------
  // Never to be used while encoding!
  // set full ROD fragment before trying to get anything!
  // in case there is more than 1 FEB in 1 fragment, jump to next FEB
  virtual inline int getNextEnergy(int& channelNumber, int32_t& energy, int32_t& time,int32_t& quality,uint32_t& gain);
  virtual int  getNextRawData(int& channelNumber, std::vector<short>& samples, uint32_t& gain);
 
  virtual inline  uint32_t  hasPhysicsBlock() const {return LE_getHeader16(LowEBlkOffset)+LE_getHeader16(HighEBlkOffset);} ;
  virtual inline  uint32_t  hasRawDataBlock() const {return LE_getHeader16(RawDataBlkOffset);} ;
 
 private:
  virtual bool setPointers();
  void clearBlocks();
  virtual void resetPointers();
  //Separated blocks for encoding
  std::vector<uint32_t>  m_LowEnergyBlock;
  std::vector<uint32_t>  m_HighEnergyBlock;
  std::vector<uint32_t>  m_RawDataBlock;
  //Counter for channels inside of a FEB
  int m_ECounter = 0;
  int m_RawDataCounter = 0;
  int m_LowEIndex = 0;
  int m_RawDataIndex = 0;
  int m_HighEIndex = 0;
  int m_EIndex = 0; //For writing....
  const int32_t *m_HighEPtr; 
  const uint32_t *m_FlagPtr;
  const int16_t *m_LowEPtr;
  //Number of flagging words at the beginning of Block 2, 3, and 4 (Depends on the number of channels)
  unsigned short m_NFlaggingWords; 
 
  const LArOnlineID* m_onlineHelper;
  static const uint32_t m_DummyBitMap[4];
  //Private functions:
  inline int FebToRodChannel(int ch) const;
  void setNextEnergy(const int32_t energy, const int32_t time, const int32_t quality, const uint32_t gain);
};
 
inline int LArRodBlockPhysicsV0::FebToRodChannel(int ch) const
  //{return ch/8 + 16 * (ch%8);}
{return (ch>>3) + ((ch&0x7)<<4);}
 
inline int LArRodBlockPhysicsV0::getNextEnergy(int& channelNumber,int32_t& energy,int32_t& time,int32_t& quality, uint32_t& gain)
{
  LARBSDBG("in LArRodBlockPhysicsV0::getEnergy.");
  LARBSDBG("m_ECounter=" << m_ECounter << "  m_RawDataIndex="<<  m_EIndex);
  LARBSDBG("m_channelsPerFEB=" << m_channelsPerFEB);
  if (m_LowEIndex+m_HighEIndex>=m_channelsPerFEB)                       //Already beyond maximal number of channels
    return 0;
  if (!m_FlagPtr || !m_LowEPtr)                                         //No data block present
    return 0;
  uint32_t gtQ;
  int rodChannelNumber=m_LowEIndex+m_HighEIndex;                        //Index of Channel in ROD-Block
  channelNumber=(rodChannelNumber>>4) + ((rodChannelNumber&0xf)<<3);    //channel number of the FEB
  if (getBit(m_FlagPtr,rodChannelNumber))                               //Data in high energy block
    {energy = m_HighEPtr[m_HighEIndex*2];
     gtQ=m_HighEPtr[m_HighEIndex*2+1];
     // Q in bits 0-15
     // t in bits 16-29
     // gain in bits 30-31
     quality  = gtQ & 0xffff;
     gtQ = gtQ >> 16;
     //time     = gtQ & 0x3fff;
     time = gtQ & 0x1fff;
     if (gtQ & 0x2000)
       time*=-1;
     gain=(gtQ >> 14);
     m_HighEIndex++;
    }
  else //Data in low energy block
    {if (!m_LowEPtr)
      return 0; //Block does not exist;
     energy=m_LowEPtr[m_LowEIndex];
     gain=0; //=CaloGain::LARHIGHGAIN
     time=0;
     quality=-1;
     m_LowEIndex++;
    }
  return 1;
}
 
#ifdef LARBSDBGOUTPUT
#undef LARBSDBGOUTPUT
#endif
#undef LARBSDBG
 
#endif