dlardaq::EventDecoder Class Reference

#include <EventDecoder.h>

Public Member Functions
	EventDecoder (size_t nch, size_t nsample)
	~EventDecoder ()
void	SetNCh (size_t val)
void	SetNSample (size_t val)
size_t	GetNCh () const
size_t	GetNSample () const
ssize_t	Open (std::string finname)
void	Close ()
ssize_t	GetEvent (size_t evnum, dlardaq::evheader_t &eh, std::vector< adc16_t > &adc)
ssize_t	GetEvent (dlardaq::evheader_t &eh, std::vector< adc16_t > &adc)
void	ReadBuffer (const char *buf, size_t nb)
bool	Compressed () const
size_t	GetTotEvents () const
runheader_t	GetRunHeader ()
evheader_t	GetEventHeader ()
footer_t	GetFileFooter ()

Public Attributes
std::ifstream	m_file

Protected Member Functions
int	lock (pthread_mutex_t &mutex)
int	trylock (pthread_mutex_t &mutex)
int	unlock (pthread_mutex_t &mutex)
void	ReadEvent (std::vector< adc16_t > &adc, bool headonly=false)
void	ReadBytes (std::vector< BYTE > &bytes)
ssize_t	Decode (const char *buf, size_t nb, bool cflag, std::vector< adc16_t > &adc)
bool	IsFirstPacket (const char *buf, size_t nb)

Protected Attributes
int	m_Verbosity
std::vector< BYTE >	m_RunHeadBuf
std::vector< BYTE >	m_EveHeadBuf
std::vector< BYTE >	m_EndFootBuf
std::vector< BYTE >	m_EveDataBuf
std::vector< adc16_t >	m_EveData
ssize_t	m_bytes_left
runheader_t	m_rnh
evheader_t	m_evh
footer_t	m_flf
std::streampos	m_pstart
std::streampos	m_pend
std::vector< std::streampos >	m_events
size_t	m_totev
short	m_nadc
size_t	m_nch
size_t	m_nsample
bool	m_dcflag
pthread_mutex_t	m_data_mutex

Detailed Description

Definition at line 25 of file EventDecoder.h.

Constructor & Destructor Documentation

EventDecoder::EventDecoder	(	size_t	nch,
		size_t	nsample
	)

Definition at line 27 of file EventDecoder_service.cc.

{
  // this is needed to read compressed data
  m_nadc    = dlardaq::BitsADC;  // bits for ADC resolution
  m_nch     = nch;               // total number of channels
  m_nsample = nsample;           // number of samples in each channel

  m_RunHeadBuf.resize( dlardaq::RunHeadSz );
  m_EveHeadBuf.resize( dlardaq::EveHeadSz  );
  m_EndFootBuf.resize( dlardaq::FileFootSz );
  
  //
  m_bytes_left = 0;

  // data mutex initialization
  pthread_mutex_init(&m_data_mutex, NULL);
}

EventDecoder::~EventDecoder

(

)

Definition at line 49 of file EventDecoder_service.cc.

{
  Close();
  pthread_mutex_destroy(&m_data_mutex);
}

Member Function Documentation

void EventDecoder::Close

(

)

Definition at line 59 of file EventDecoder_service.cc.

{
  // lock mutex
  lock( m_data_mutex );

  if(m_file.is_open())
    m_file.close();  
  
  m_totev = 0;
  
  // unlock mutex
  unlock( m_data_mutex );
}

bool dlardaq::EventDecoder::Compressed ( ) const

inline

Definition at line 55 of file EventDecoder.h.

{ return m_dcflag; }

ssize_t EventDecoder::Decode ( const char *  buf, size_t  nb, bool  cflag, std::vector< adc16_t > &  adc  )

protected

Definition at line 261 of file EventDecoder_service.cc.

{
  adc.clear();

  if( !cflag ) //not compressed
    {
      adc.resize( (nb*8)/m_nadc, 0 );
      unpack12into16( buf, &adc[0], nb );
    }
  else
    {
      size_t byteidx = 0;
      HuffDataCompressor::Instance().DecompressEventData(m_nadc, m_nch, m_nsample, buf, nb, byteidx, adc);
      
    }  

  return adc.size();
}

ssize_t EventDecoder::GetEvent	(	size_t	evnum,
		dlardaq::evheader_t &	eh,
		std::vector< adc16_t > &	adc
	)

Definition at line 185 of file EventDecoder_service.cc.

{
  adc.clear();
  if(!m_file.is_open()) return -1;
  //if(evnum >= m_totev)  return -1; //no-can-do
  lock(m_data_mutex);

  if(evnum < m_events.size())  // already know where it is
    {
      m_file.seekg(m_events[evnum]);
      ReadEvent( adc );
      eh = m_evh;
    }
  else
    {
      size_t curev = m_events.size();
      while( curev <= evnum )
        {
          // our event begins at this position
          streampos pos = m_file.tellg();
          m_events.push_back( pos );
          
          // readonly header to get event data size
          if( curev < evnum ) 
            ReadEvent(adc, true);
          else // event we want
            ReadEvent(adc, false);
          
          curev++;
        }
      
      // last event is the one with want ...
      eh = m_evh;
    }

  unlock(m_data_mutex);

  return evnum;
}

ssize_t EventDecoder::GetEvent	(	dlardaq::evheader_t &	eh,
		std::vector< adc16_t > &	adc
	)

Definition at line 229 of file EventDecoder_service.cc.

{
  if(m_file.is_open())
    {
      // return first event
      return GetEvent( 0, eh, adc);
    }

  ssize_t rval = -1;
  //else // we have an event buffer
  if( m_EveData.empty() ) return -1;

  // lock mutex
  lock(m_data_mutex);

  eh  = m_evh;  
  adc = m_EveData;

  // clear the internal data buffer
  m_EveData.clear();
  
  rval = eh.ev_num;
  
  // unlock mutex
  unlock(m_data_mutex);
  return rval;
}

evheader_t dlardaq::EventDecoder::GetEventHeader ( )

inline

Definition at line 61 of file EventDecoder.h.

{ return m_evh; }

footer_t dlardaq::EventDecoder::GetFileFooter ( )

inline

Definition at line 62 of file EventDecoder.h.

{ return m_flf; }

size_t dlardaq::EventDecoder::GetNCh ( ) const

inline

Definition at line 34 of file EventDecoder.h.

{ return m_nch; }

size_t dlardaq::EventDecoder::GetNSample ( ) const

inline

Definition at line 35 of file EventDecoder.h.

{ return m_nsample; }

runheader_t dlardaq::EventDecoder::GetRunHeader ( )

inline

Definition at line 60 of file EventDecoder.h.

{ return m_rnh; }

size_t dlardaq::EventDecoder::GetTotEvents ( ) const

inline

Definition at line 58 of file EventDecoder.h.

{ return m_totev; }

bool EventDecoder::IsFirstPacket ( const char *  buf, size_t  nb  )

protected

Definition at line 392 of file EventDecoder_service.cc.

{
  BYTE k0 = buf[dlardaq::RunHeadSz];
  BYTE k1 = buf[dlardaq::RunHeadSz+1];
  bool rval = ( ((k0 & 0xFF) == EVSKEY) && ((k1 & 0xFF) == EVSKEY) );
  
  return rval;
}

int dlardaq::EventDecoder::lock ( pthread_mutex_t &  mutex )

inlineprotected

Definition at line 67 of file EventDecoder.h.

{ return  pthread_mutex_lock(&mutex); }

ssize_t EventDecoder::Open

(

std::string

finname

)

Definition at line 78 of file EventDecoder_service.cc.

{
  // attempt to close any previously opened files
  Close();
  
  lock( m_data_mutex );

  m_EveData.clear(); // not used when reading from file

  // clear event bookmarks
  m_events.clear();

  //
  m_file.open(finname.c_str(), ios::in | ios::binary);
  
  if( !m_file.is_open() )
    {
      msg_err<<"Could not open "<<finname<<" for reading"<<endl;
      unlock( m_data_mutex );
      return -1;
    }
  
  // read run header bytes
  ReadBytes( m_RunHeadBuf );
  dlardaq::decode_runhead(&m_RunHeadBuf[0], m_rnh);
  
  
  m_pstart = m_file.tellg();
  
  // read footer
  // fast forward to the end
  m_file.seekg(-dlardaq::FileFootSz, m_file.end );
  m_pend = m_file.tellg();
  
  ReadBytes( m_EndFootBuf );
  dlardaq::decode_filefoot(&m_EndFootBuf[0], m_flf);

  // rewind back to the begining
  m_file.seekg( m_pstart );

  
  // 

  m_totev = m_flf.num_events;
  
  if( m_totev == 0 )
    {
      msg_err<<"File "<<finname<<" is empty"<<endl;
      unlock(m_data_mutex);
      Close();
      return 0;
    }

  unlock( m_data_mutex );
  
  return m_totev;
}

void EventDecoder::ReadBuffer	(	const char *	buf,
		size_t	nb
	)

Definition at line 286 of file EventDecoder_service.cc.

{
  if(m_file.is_open())
    {
      msg_err<<"Cannot use this function while reading data from a file"<<endl;
      return;
    }
  
  // lock mutex
  lock(m_data_mutex);
  m_totev = 0;  
  if(!m_EveData.empty()) m_EveData.clear();
  
  // we have finished reading previous event
  if( m_bytes_left <= 0 || 
      Timer::GetTimer().splittime(false, false) > TMAXWAIT)
    {
      m_EveDataBuf.clear();
      if(IsFirstPacket(buf, nb)) //check we have a correct packet
        {
          // decode header
          size_t  nb_read = 0;
          const char *pdata = buf;
          
          // decode run header
          ssize_t ret;
          ret = dlardaq::decode_runhead(pdata, m_rnh);
          if( ret <= 0) 
            {
              // unlock mutex
              unlock(m_data_mutex);
              return;
            }
          pdata   += ret;
          nb_read += ret;

          // decode event header
          ret = dlardaq::decode_evehead(pdata, m_evh);
          if( ret <= 0) 
            {
              // unlock mutex
              unlock(m_data_mutex);
              return;
            }
          pdata   += ret;
          nb_read += ret;
          
          m_bytes_left = m_evh.ev_size;
          if(m_bytes_left <= 0) 
            {
              // unlock mutex
              unlock(m_data_mutex);
              return;
            }
          
          //msg_info<<"Start recieving event "<<m_evh.ev_num<<endl;

          // copy the data
          m_EveDataBuf.insert(m_EveDataBuf.end(), pdata, pdata + nb-nb_read);
          m_bytes_left -= (nb - nb_read);
                  
          // start timer 
          Timer::GetTimer().start();

          //
          unlock(m_data_mutex);
          return;
        }
      else
        {
          unlock(m_data_mutex);
          return;
        }
    }
  
  // append to buffer
  m_EveDataBuf.insert(m_EveDataBuf.end(), buf, buf+nb);
  m_bytes_left -= nb;
  if( m_bytes_left < 0 )
    {
      msg_err<<"Byte packet mismatch"<<endl;
      
      // unlock mutex
      unlock(m_data_mutex);
      return;
    }

  // we have full event
  if( m_bytes_left == 0 )
    {
      // decode data
      bool cflag =  GETDCFLAG(m_evh.dq_flag);
      Decode( &m_EveDataBuf[0], m_EveDataBuf.size(), cflag, m_EveData );
      m_totev = 1;
      
      msg_info<<"Recieved: run "<<m_rnh.run_num<<" event "<<m_evh.ev_num<<endl;
    }
    
  // unlock mutex
  unlock(m_data_mutex);
}

void EventDecoder::ReadBytes ( std::vector< BYTE > &  bytes )

protected

Definition at line 139 of file EventDecoder_service.cc.

{
  m_file.read( &bytes[0], bytes.size() );
}

void EventDecoder::ReadEvent ( std::vector< adc16_t > &  adc, bool  headonly = false  )

protected

Definition at line 148 of file EventDecoder_service.cc.

{
  // first read the header
  ReadBytes( m_EveHeadBuf );
  decode_evehead(&m_EveHeadBuf[0], m_evh);  
  //dlardaq::msg_info<<">>> Event number "<<m_evh.ev_num<<endl;
  //dlardaq::msg_info<<">>> Event size   "<<m_evh.ev_size<<endl;
  //dlardaq::msg_info<<">>> Trig number  "<<m_evh.trig_info.num<<endl;
  //dlardaq::msg_info<<">>> Time stamp   "<<m_evh.trig_info.ts.tv_sec<<" s "
  //<<m_evh.trig_info.ts.tv_nsec<<" ns"<<endl;
  //dlardaq::msg_info<<">>> Flags "<<bitset<8>(m_evh.dq_flag)<<endl;

  
  if(headonly) // read only header and skip to next event
    {
      // get event size
      size_t evsz = m_evh.ev_size;

      // move to next event
      m_file.seekg(evsz, std::ios::cur);
      return;
    }

  //
  // decode event data
  if(!m_EveDataBuf.empty()) m_EveDataBuf.clear();
  
  m_EveDataBuf.resize(m_evh.ev_size, '\0');
  
  // read content of the file
  ReadBytes(m_EveDataBuf);
  Decode( &m_EveDataBuf[0], m_EveDataBuf.size(), GETDCFLAG(m_evh.dq_flag), adc );
}

void dlardaq::EventDecoder::SetNCh ( size_t  val )

inline

Definition at line 31 of file EventDecoder.h.

{ m_nch = val; }

void dlardaq::EventDecoder::SetNSample ( size_t  val )

inline

Definition at line 32 of file EventDecoder.h.

{ m_nsample = val; }

int dlardaq::EventDecoder::trylock ( pthread_mutex_t &  mutex )

inlineprotected

Definition at line 68 of file EventDecoder.h.

{ return  pthread_mutex_trylock(&mutex); }

int dlardaq::EventDecoder::unlock ( pthread_mutex_t &  mutex )

inlineprotected

Definition at line 69 of file EventDecoder.h.

{ return  pthread_mutex_unlock(&mutex); }   

Member Data Documentation

ssize_t dlardaq::EventDecoder::m_bytes_left

protected

Definition at line 93 of file EventDecoder.h.

pthread_mutex_t dlardaq::EventDecoder::m_data_mutex

protected

Definition at line 118 of file EventDecoder.h.

bool dlardaq::EventDecoder::m_dcflag

protected

Definition at line 115 of file EventDecoder.h.

std::vector<BYTE> dlardaq::EventDecoder::m_EndFootBuf

protected

Definition at line 87 of file EventDecoder.h.

std::vector<adc16_t> dlardaq::EventDecoder::m_EveData

protected

Definition at line 90 of file EventDecoder.h.

std::vector<BYTE> dlardaq::EventDecoder::m_EveDataBuf

protected

Definition at line 88 of file EventDecoder.h.

std::vector<BYTE> dlardaq::EventDecoder::m_EveHeadBuf

protected

Definition at line 86 of file EventDecoder.h.

std::vector<std::streampos> dlardaq::EventDecoder::m_events

protected

Definition at line 104 of file EventDecoder.h.

evheader_t dlardaq::EventDecoder::m_evh

protected

Definition at line 98 of file EventDecoder.h.

std::ifstream dlardaq::EventDecoder::m_file

Definition at line 64 of file EventDecoder.h.

footer_t dlardaq::EventDecoder::m_flf

protected

Definition at line 99 of file EventDecoder.h.

short dlardaq::EventDecoder::m_nadc

protected

Definition at line 110 of file EventDecoder.h.

size_t dlardaq::EventDecoder::m_nch

protected

Definition at line 111 of file EventDecoder.h.

size_t dlardaq::EventDecoder::m_nsample

protected

Definition at line 112 of file EventDecoder.h.

std::streampos dlardaq::EventDecoder::m_pend

protected

Definition at line 103 of file EventDecoder.h.

std::streampos dlardaq::EventDecoder::m_pstart

protected

Definition at line 102 of file EventDecoder.h.

runheader_t dlardaq::EventDecoder::m_rnh

protected

Definition at line 97 of file EventDecoder.h.

std::vector<BYTE> dlardaq::EventDecoder::m_RunHeadBuf

protected

Definition at line 85 of file EventDecoder.h.

size_t dlardaq::EventDecoder::m_totev

protected

Definition at line 107 of file EventDecoder.h.

int dlardaq::EventDecoder::m_Verbosity

protected

Definition at line 83 of file EventDecoder.h.

---

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

• duneprototypes/duneprototypes/3x1x1dp/DataImport/Services/EventDecoder.h
• duneprototypes/duneprototypes/3x1x1dp/DataImport/Services/EventDecoder_service.cc