ZdcLucrodDecoder Class Reference

#include <ZdcLucrodDecoder.h>

Inheritance diagram for ZdcLucrodDecoder:

Collaboration diagram for ZdcLucrodDecoder:

Public Member Functions
	ZdcLucrodDecoder (unsigned int expectedSrcIDHigh, unsigned int expectedRODVersion=0x301)
	~ZdcLucrodDecoder ()
StatusCode	decode (const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *robFragment, ZdcLucrodData *zld)
MsgStream &	msg (MSG::Level lvl) const
bool	msgLevel (MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Types
enum	{ ROD_MARKER = 0xee1234ee , ROD_NCHANNELS = 8 }

Private Member Functions
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
unsigned short	m_sourceIdHigh
unsigned short	m_rodVersion
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels)
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging)

Detailed Description

Definition at line 19 of file ZdcLucrodDecoder.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
ROD_MARKER
ROD_NCHANNELS

Definition at line 21 of file ZdcLucrodDecoder.h.

       {ROD_MARKER = 0xee1234ee,
    ROD_NCHANNELS = 8};

Constructor & Destructor Documentation

ZdcLucrodDecoder()

ZdcLucrodDecoder::ZdcLucrodDecoder ( unsigned int expectedSrcIDHigh, unsigned int expectedRODVersion = 0x301 )

inline

Definition at line 26 of file ZdcLucrodDecoder.h.

                                                                                           :  
  AthMessaging(Athena::getMessageSvc(), "ZdcLucrodDecoder"),
    m_sourceIdHigh(expectedSrcIDHigh), m_rodVersion(expectedRODVersion)
  {};

~ZdcLucrodDecoder()

ZdcLucrodDecoder::~ZdcLucrodDecoder ( )

inline

Definition at line 32 of file ZdcLucrodDecoder.h.

{};

Member Function Documentation

decode()

StatusCode ZdcLucrodDecoder::decode	(	const OFFLINE_FRAGMENTS_NAMESPACE::ROBFragment *	robFragment,
		ZdcLucrodData *	zld )

Definition at line 10 of file ZdcLucrodDecoder.cxx.

                                                                                                                 {
  
  if (msgLevel(MSG::DEBUG)) msg(MSG::DEBUG) << " ZdcLucrodDecoder::decode" << endreq;
  
  uint32_t ROD_run_no            = robFragment->rod_run_no();
  uint32_t ROD_lvl1_id           = robFragment->rod_lvl1_id();
  uint32_t ROD_bc_id             = robFragment->rod_bc_id();
  uint32_t ROD_lvl1_trigger_type = robFragment->rod_lvl1_trigger_type();
  uint32_t ROD_detev_type        = robFragment->rod_detev_type();
  uint32_t ROD_marker            = robFragment->rod_marker();
  uint32_t ROD_fragment_size     = robFragment->rod_fragment_size_word();
  uint32_t ROD_header_size       = robFragment->rod_header_size_word();
  uint32_t ROD_trailer_size      = robFragment->rod_trailer_size_word();
  uint32_t ROD_version           = robFragment->rod_version() >> 16;     // extract the upper 16 bits
  uint32_t ROD_sourceID          = robFragment->rod_source_id();
  uint32_t ROD_nstatus           = robFragment->rod_nstatus();
  uint32_t ROD_ndata             = robFragment->rod_ndata(); 
  uint32_t ROD_status_pos        = robFragment->rod_status_position();
 
  uint32_t ROD_sourceID_high = ROD_sourceID >> 16; // extract the upper 16 bits
 
  if (msgLevel(MSG::DEBUG)) 
    msg(MSG::DEBUG) 
      << " ROD_run_no:            "   << std::dec << ROD_run_no            << endreq
      << " ROD_lvl1_id:           0x" << std::hex << ROD_lvl1_id           << endreq
      << " ROD_bc_id:             "   << std::dec << ROD_bc_id             << endreq
      << " ROD_lvl1_trigger_type: "   << std::dec << ROD_lvl1_trigger_type << endreq
      << " ROD_detev_type:        "   << std::dec << ROD_detev_type        << endreq
      << " ROD_marker:            0x" << std::hex << ROD_marker            << endreq
      << " ROD_fragment_size:     "   << std::dec << ROD_fragment_size     << endreq
      << " ROD_header_size:       "   << std::dec << ROD_header_size       << endreq
      << " ROD_trailer_size:      "   << std::dec << ROD_trailer_size      << endreq
      << " ROD_version:           0x" << std::hex << ROD_version           << endreq
      << " ROD_source_ID:         0x" << std::hex << ROD_sourceID         << endreq
      << " ROD_nstatus:           "   << std::dec << ROD_nstatus           << endreq
      << " ROD_ndata:             "   << std::dec << ROD_ndata             << endreq
      << " ROD_status_pos:        "   << std::dec << ROD_status_pos        << endreq
      << std::dec;
 
  // Check for  valid marker
  //
  if (ROD_marker        != ROD_MARKER)        {
    msg(MSG::ERROR) << " ERROR: Invalid ROD_marker " <<  std::hex << ROD_marker << endreq;
    return StatusCode::FAILURE;
  }
  
  // Check for expected ROD format version
  //
  if (ROD_version      != m_rodVersion)   {
    msg(MSG::ERROR) << " ERROR: Incorrect ROD_version, expected  " << m_rodVersion
            << ", found " << (ROD_version>>16) << endreq;
    return StatusCode::FAILURE; 
  }
 
  // Check for ZDC detector ID in upper bits
  //
  if (ROD_sourceID_high  != m_sourceIdHigh)
  {
    msg(MSG::ERROR) << " ERROR: invalid source ID detector word, " << ROD_sourceID << endreq;
    return StatusCode::FAILURE;
  }
  
  unsigned int nwordsNoTrig = ROD_ndata - 5; // Five words for per-module amplitudes and per-side sums/4
 
  // There should be 32 words per bunch crossing: 1/2 word for each of eight samples * 8 channels
  //
  if (nwordsNoTrig % 32 != 0) {
    msg(MSG::WARNING) << " WARNING: incorrect number of words in ROD data: " << ROD_ndata << endreq;
    return StatusCode::FAILURE;
  }
 
  unsigned int numBCRead = ROD_ndata/32;
  
  if (msgLevel(MSG::DEBUG)) msg(MSG::DEBUG) << " Fill ZdcLucrodData, with " << numBCRead << " bunch crossings" << endreq; 
  
  zld->SetBCID     (ROD_bc_id);
  zld->SetRunNumber(ROD_run_no);
  zld->SetLevel1ID (ROD_lvl1_id);
  zld->SetNumBCs(numBCRead);
 
  OFFLINE_FRAGMENTS_NAMESPACE::PointerType vintData;
  OFFLINE_FRAGMENTS_NAMESPACE::PointerType vintStat;
  
  robFragment->rod_data  (vintData);
  robFragment->rod_status(vintStat);
  
  uint32_t            channel = 0xffff;  
  std::vector<uint16_t> waveform;
 
  uint32_t wordIt=0;
  uint32_t word  =0;
 
  while (wordIt<ROD_ndata) {
    
    word = vintData[wordIt]; wordIt++;
 
    if ((word & 0xf0000000) >> 28 == 0xc) { // start of trigger data
 
      if (waveform.size()) {
    if (!zld->AddChanData(channel, waveform)) {
      msg(MSG::ERROR) << " ERROR: inconsistency in LUCROD data" << endreq;
      return StatusCode::FAILURE;
    }
      }
      break;      
    }
    
    // ADCs are all shorts
    uint16_t adc1 =  word & 0xfff;
    uint16_t adc2 = (word & 0xfff0000)  >> 16;
    uint16_t cid1 = (word & 0x7000)     >> 12;
    uint16_t cid2 = (word & 0x70000000) >> 28;
 
    if (msgLevel(MSG::DEBUG)) 
      msg(MSG::DEBUG)
    << " adc1: " << adc1
    << " adc2: " << adc2
    << " cid1: " << cid1
    << " cid2: " << cid2 
    << endreq;
 
    if (cid1 != cid2) return StatusCode::FAILURE;
    
    if (channel == cid1) {
      
      waveform.push_back(adc1);
      waveform.push_back(adc2);
    }
    else { // new channel
      if (waveform.size()) {
    if (!zld->AddChanData(channel, waveform)) {
      msg(MSG::ERROR) << " ERROR: inconsistency in LUCROD data" << endreq;
      return StatusCode::FAILURE;
    } 
      }
      
      channel = cid1; // shouldn't this go before the line above?
      
      waveform.clear();
      waveform.push_back(adc1);
      waveform.push_back(adc2);
    }
  }
  
  
  // this can adapt
  if ((word & 0xf000) >> 12 != 0xa) return StatusCode::FAILURE;
  
  uint16_t trigAvgA =  (word & 0xfff);
  uint16_t trigAvgC = ((word & 0xfff0000)>>16);
 
  if (msgLevel(MSG::DEBUG)) 
    msg(MSG::DEBUG)
      << " trigAvgA: " << trigAvgA
      << " trigAvgC: " << trigAvgC
      << endreq;
 
  zld->SetTrigAvgA(trigAvgA);
  zld->SetTrigAvgC(trigAvgC);
 
  // Loop over all data words in the fragment
  //
  while (wordIt<ROD_ndata) { 
    
    word = vintData[wordIt]; wordIt++;
 
    if ((word & 0xf0000000) >> 28 != 0xb) return StatusCode::FAILURE;
    
    uint16_t amp1 = (word & 0xfff);         // 12 bit ADC
    uint16_t amp2 = (word & 0xfff0000)>>16;
    
    if (msgLevel(MSG::DEBUG)) 
      msg(MSG::DEBUG)
    << " amp1: " << amp1
    << " amp2: " << amp2
    << endreq;
    
    zld->AddTrigData(amp1);
    zld->AddTrigData(amp2);
  }
  
  if (msgLevel(MSG::DEBUG)) 
    msg(MSG::DEBUG) 
      << " ChanDataSize: " << zld->GetChanDataSize() 
      << " TrigDataSize: " << zld->GetTrigDataSize() 
      << endreq;
                
  if (zld->GetChanDataSize() != ROD_NCHANNELS) { if (msgLevel(MSG::DEBUG)) msg(MSG::DEBUG) << " ERROR: ChanDataSize " << endreq; return StatusCode::FAILURE; }
  if (zld->GetTrigDataSize() != ROD_NCHANNELS) { if (msgLevel(MSG::DEBUG)) msg(MSG::DEBUG) << " ERROR: TrigDataSize " << endreq; return StatusCode::FAILURE; }
 
  zld->SetStatus(vintStat[0]);
  
  return StatusCode::SUCCESS;
}

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 163 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & ZdcLucrodDecoder::msg ( MSG::Level lvl ) const

inline

Definition at line 36 of file ZdcLucrodDecoder.h.

{ return AthMessaging::msg() << lvl; }

msgLevel()

bool ZdcLucrodDecoder::msgLevel ( MSG::Level lvl ) const

inline

Definition at line 38 of file ZdcLucrodDecoder.h.

{ return AthMessaging::msgLvl(lvl); }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging)

Definition at line 141 of file AthMessaging.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels)

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_rodVersion

unsigned short ZdcLucrodDecoder::m_rodVersion

private

Definition at line 43 of file ZdcLucrodDecoder.h.

m_sourceIdHigh

unsigned short ZdcLucrodDecoder::m_sourceIdHigh

private

Definition at line 42 of file ZdcLucrodDecoder.h.

---

The documentation for this class was generated from the following files:

• ZdcLucrodDecoder.h
• ZdcLucrodDecoder.cxx