dune::PennMilliSlice Class Reference

#include <PennMilliSlice.hh>

Inheritance diagram for dune::PennMilliSlice:

Classes
struct	Header

Public Member Functions
	PennMilliSlice (uint8_t *address)
Header::millislice_size_t	size () const
Header::sequence_id_t	sequenceID () const
Header::version_t	version () const
Header::timestamp_t	endTimestamp () const
Header::ticks_t	widthTicks () const
Header::ticks_t	overlapTicks () const
Header::payload_count_t	payloadCount () const
Header::payload_count_t	payloadCount (Header::payload_count_t &counter, Header::payload_count_t &trigger, Header::payload_count_t &timestamp ) const
uint8_t *	payload (uint32_t index, dune::PennMicroSlice::Payload_Header::data_packet_type_t &data_packet_type, dune::PennMicroSlice::Payload_Header::short_nova_timestamp_t &short_nova_timestamp, size_t &payload_size) const
uint8_t *	payload (uint32_t index, dune::PennMicroSlice::Payload_Header *&data_header) const
uint8_t *	get_next_payload (uint32_t &index, dune::PennMicroSlice::Payload_Header::data_packet_type_t &data_packet_type, dune::PennMicroSlice::Payload_Header::short_nova_timestamp_t &short_nova_timestamp, size_t &payload_size)
uint8_t *	get_next_payload (uint32_t &index, dune::PennMicroSlice::Payload_Header *&data_header)
uint8_t *	get_next_timestamp (dune::PennMicroSlice::Payload_Header *&data_header)

Protected Member Functions
Header const *	header_ () const
uint8_t *	data_ (int index) const

Protected Attributes
uint8_t *	buffer_
uint8_t *	current_payload_
uint32_t	current_word_id_

Detailed Description

Definition at line 16 of file PennMilliSlice.hh.

Constructor & Destructor Documentation

dune::PennMilliSlice::PennMilliSlice

(

uint8_t *

address

)

Definition at line 8 of file PennMilliSlice.cc.

                                                   : buffer_(address), current_payload_(address), current_word_id_(0)
{
}

Member Function Documentation

uint8_t * dune::PennMilliSlice::data_ ( int  index ) const

protected

Definition at line 420 of file PennMilliSlice.cc.

{
  uint8_t* ms_ptr = buffer_ + sizeof(Header);
  for (int idx = 0; idx < index; ++idx) {
    PennMicroSlice tmp_ms(ms_ptr);
    ms_ptr += tmp_ms.size();
  }
  return ms_ptr;
}

dune::PennMilliSlice::Header::timestamp_t dune::PennMilliSlice::endTimestamp

(

)

const

Definition at line 34 of file PennMilliSlice.cc.

{
  return header_()->end_timestamp;
}

uint8_t * dune::PennMilliSlice::get_next_payload	(	uint32_t &	index,
		dune::PennMicroSlice::Payload_Header::data_packet_type_t &	data_packet_type,
		dune::PennMicroSlice::Payload_Header::short_nova_timestamp_t &	short_nova_timestamp,
		size_t &	payload_size
	)

Definition at line 80 of file PennMilliSlice.cc.

{

  if(current_word_id_ == 0){
    current_payload_ = buffer_ + sizeof(Header);
  }
  else{
    //current_payload_ points to the last payload served up
    //We need to skip over this one
    dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(current_payload_);
    dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
    switch(type)
      {
      case dune::PennMicroSlice::DataTypeCounter:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_counter;
        break;
      case dune::PennMicroSlice::DataTypeTrigger:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_trigger;
        break;
      case dune::PennMicroSlice::DataTypeTimestamp:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_timestamp;
        break;
      case dune::PennMicroSlice::DataTypeWarning:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_warning;
        break;
      case dune::PennMicroSlice::DataTypeChecksum:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_checksum;
        break;
      default:
//      std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
        return nullptr;
        break;
      }//switch(type)
  }//(current_word_id_ != 0)

  //Now current_payload_ will point to the next payload. Process the information that we want

  //Need to make sure we have not gone off the end of the buffer
  if(current_payload_ >= (buffer_ + size())) 
    return nullptr;
  

  dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(current_payload_);
  dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;

  //Set the variables passed as references
  index = current_word_id_;
  type = payload_header->data_packet_type;
  data_packet_type = type;
  short_nova_timestamp = payload_header->short_nova_timestamp;

  switch(type)
    {
    case dune::PennMicroSlice::DataTypeCounter:
      payload_size = dune::PennMicroSlice::payload_size_counter;
      break;
    case dune::PennMicroSlice::DataTypeTrigger:
      payload_size = dune::PennMicroSlice::payload_size_trigger;
      break;
    case dune::PennMicroSlice::DataTypeTimestamp:
      payload_size = dune::PennMicroSlice::payload_size_timestamp;
      break;
    case dune::PennMicroSlice::DataTypeWarning:
      payload_size = dune::PennMicroSlice::payload_size_warning;
      break;
    case dune::PennMicroSlice::DataTypeChecksum:
      payload_size = dune::PennMicroSlice::payload_size_checksum;
      break;
    default:
      //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
      payload_size = 0;
      break;
    }//switch(type)

  current_word_id_++;
  //current_payload_ points at the Payload_Header of the next payload
  //this function assumes that state is true the next time it is called (so it knows how to shift to the next payload)
  //but the user is expecting just the payload data. Therefore return the buffer offset by the payload_header

  return (current_payload_ + dune::PennMicroSlice::Payload_Header::size_bytes);

}

uint8_t * dune::PennMilliSlice::get_next_payload	(	uint32_t &	index,
		dune::PennMicroSlice::Payload_Header *&	data_header
	)

Definition at line 167 of file PennMilliSlice.cc.

                                                                                                            {

  // If we are still at the beginning, shift to the beginning of the Millislice and
  // jump over its header
  if(current_word_id_ == 0) {
    current_payload_ = buffer_ + sizeof(Header);
  }
  else{
    //current_payload_ points to the last payload served
    //We need to skip over this one
    dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(current_payload_);
    dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
    switch(type)
      {
      case dune::PennMicroSlice::DataTypeCounter:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_counter;
        break;
      case dune::PennMicroSlice::DataTypeTrigger:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_trigger;
        break;
      case dune::PennMicroSlice::DataTypeTimestamp:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_timestamp;
        break;
      case dune::PennMicroSlice::DataTypeWarning:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_warning;
        break;
      case dune::PennMicroSlice::DataTypeChecksum:
        current_payload_ += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_checksum;
        break;
      default:
        //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
        return nullptr;
        break;
      }//switch(type)
  }//(current_word_id_ != 0)

  //Now current_payload_ will point to the next payload. Process the information that we want

  //Need to make sure we have not gone off the end of the buffer
  if(current_payload_ >= (buffer_ + size()))
    return nullptr;


  dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(current_payload_);
  //dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
  
  //Set the variables passed as references
  index = current_word_id_;
  //type = payload_header->data_packet_type;
  data_header = payload_header;

  current_word_id_++;
  //current_payload_ points at the Payload_Header of the next payload
  //this function assumes that state is true the next time it is called (so it knows how to shift to the next payload)
  //but the user is expecting just the payload data. Therefore return the buffer offset by the payload_header

  return (current_payload_ + dune::PennMicroSlice::Payload_Header::size_bytes);

}

uint8_t * dune::PennMilliSlice::get_next_timestamp

(

dune::PennMicroSlice::Payload_Header *&

data_header

)

Definition at line 229 of file PennMilliSlice.cc.

                                                                                              {
  uint8_t* pl_ptr = current_payload_;
  bool found = false;
  if(current_word_id_ == 0) {
    pl_ptr = buffer_ + sizeof(Header);
  }
  dune::PennMicroSlice::Payload_Header* payload_header = nullptr;
  while (!found && (pl_ptr < (buffer_ + size()))) {
    //current_payload_ points to the last payload served
    //We need to skip over this one
    payload_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(pl_ptr);
    dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
    switch(type)
      {
      case dune::PennMicroSlice::DataTypeCounter:
        pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_counter;
        break;
      case dune::PennMicroSlice::DataTypeTrigger:
        pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_trigger;
        break;
      case dune::PennMicroSlice::DataTypeTimestamp:
          found = true;
          break;
      case dune::PennMicroSlice::DataTypeWarning:
        pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_warning;
        break;
      case dune::PennMicroSlice::DataTypeChecksum:
        pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_checksum;
        break;
      default:
        //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
        data_header = nullptr;
        return nullptr;
        break;
      }//switch(type)
  }

  if (found) {
    data_header = reinterpret_cast_checked<dune::PennMicroSlice::Payload_Header*>(pl_ptr);
    return (pl_ptr + dune::PennMicroSlice::Payload_Header::size_bytes);
  }
  else return nullptr;
}

dune::PennMilliSlice::Header const * dune::PennMilliSlice::header_ ( ) const

protected

Definition at line 414 of file PennMilliSlice.cc.

{
  return reinterpret_cast<Header const*>(buffer_);
}

dune::PennMilliSlice::Header::ticks_t dune::PennMilliSlice::overlapTicks

(

)

const

Definition at line 44 of file PennMilliSlice.cc.

{
  return header_()->overlap_in_ticks;
}

uint8_t * dune::PennMilliSlice::payload	(	uint32_t	index,
		dune::PennMicroSlice::Payload_Header::data_packet_type_t &	data_packet_type,
		dune::PennMicroSlice::Payload_Header::short_nova_timestamp_t &	short_nova_timestamp,
		size_t &	payload_size
	)		const

Definition at line 315 of file PennMilliSlice.cc.

{
  uint32_t i = 0;
  uint8_t* pl_ptr = buffer_ + sizeof(Header);
  while(pl_ptr < (buffer_ + size())) {
    dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast<dune::PennMicroSlice::Payload_Header*>(pl_ptr);
    dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
    if(i == index) {
      data_packet_type = type;
      short_nova_timestamp = payload_header->short_nova_timestamp;
#ifdef __DEBUG_payload__
    std::cout << "PennMilliSlice::payload() payload  " << i << " has type 0x"
        << std::hex << (unsigned int)data_packet_type << std::dec
        << " " << std::bitset<3>(data_packet_type)
        << " and timestamp " << short_nova_timestamp
        << " " << std::bitset<28>(short_nova_timestamp)
        << " payload header bits " << std::bitset<32>(*((uint32_t*)pl_ptr))
        << std::endl;
#endif
      pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes;
      switch(type)
  {
  case dune::PennMicroSlice::DataTypeCounter:
    payload_size = dune::PennMicroSlice::payload_size_counter;
    break;
  case dune::PennMicroSlice::DataTypeTrigger:
    payload_size = dune::PennMicroSlice::payload_size_trigger;
    break;
  case dune::PennMicroSlice::DataTypeTimestamp:
    payload_size = dune::PennMicroSlice::payload_size_timestamp;
    break;
  case dune::PennMicroSlice::DataTypeWarning:
    payload_size = dune::PennMicroSlice::payload_size_warning;
    break;
  case dune::PennMicroSlice::DataTypeChecksum:
    payload_size = dune::PennMicroSlice::payload_size_checksum;
    break;
  default:
    //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
    payload_size = 0;
    break;
  }//switch(type)
      return pl_ptr;
    }
    switch(type)
      {
      case dune::PennMicroSlice::DataTypeCounter:
  pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_counter;
  break;
      case dune::PennMicroSlice::DataTypeTrigger:
  pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_trigger;
  break;
      case dune::PennMicroSlice::DataTypeTimestamp:
  pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_timestamp;
  break;
      case dune::PennMicroSlice::DataTypeWarning:
  pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_warning;
  break;
      case dune::PennMicroSlice::DataTypeChecksum:
  pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes + dune::PennMicroSlice::payload_size_checksum;
  break;
      default:
  //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
  return nullptr;
  break;
      }//switch(type)
    i++;
  }
  std::cerr << "Could not find payload with ID " << index << " (the data buffer has overrun)" << std::endl;
  payload_size = 0;
  return nullptr;
}

uint8_t * dune::PennMilliSlice::payload	(	uint32_t	index,
		dune::PennMicroSlice::Payload_Header *&	data_header
	)		const

Definition at line 274 of file PennMilliSlice.cc.

{
  uint32_t i = 0;
  uint8_t* pl_ptr = buffer_ + sizeof(Header);
  while(pl_ptr < (buffer_ + size())) {
    dune::PennMicroSlice::Payload_Header* payload_header = reinterpret_cast<dune::PennMicroSlice::Payload_Header*>(pl_ptr);
    dune::PennMicroSlice::Payload_Header::data_packet_type_t type = payload_header->data_packet_type;
    if(i == index) {
      data_header = payload_header;
      pl_ptr += dune::PennMicroSlice::Payload_Header::size_bytes;
      return pl_ptr;
    }
    switch(type) {
      case dune::PennMicroSlice::DataTypeCounter:
        pl_ptr += dune::PennMicroSlice::payload_size_counter;
        break;
      case dune::PennMicroSlice::DataTypeTrigger:
        pl_ptr += dune::PennMicroSlice::payload_size_trigger;
        break;
      case dune::PennMicroSlice::DataTypeTimestamp:
        pl_ptr += dune::PennMicroSlice::payload_size_timestamp;
        break;
      case dune::PennMicroSlice::DataTypeWarning:
        pl_ptr += dune::PennMicroSlice::payload_size_warning;
        break;
      case dune::PennMicroSlice::DataTypeChecksum:
        pl_ptr += dune::PennMicroSlice::payload_size_checksum;
        break;
      default:
        //std::cerr << "Unknown data packet type found 0x" << std::hex << (unsigned int)type << std::endl;
        return nullptr;
        break;
      }//switch(type)
    ++i;
  }
  std::cerr << "Could not find payload with index " << index << " (the data buffer has overrun)" << std::endl;
  return nullptr;
}

dune::PennMilliSlice::Header::payload_count_t dune::PennMilliSlice::payloadCount

(

)

const

Definition at line 49 of file PennMilliSlice.cc.

{
  return header_()->payload_count;
}

dune::PennMilliSlice::Header::payload_count_t dune::PennMilliSlice::payloadCount	(	Header::payload_count_t &	counter,
		Header::payload_count_t &	trigger,
		Header::payload_count_t &	timestamp
	)		const

Definition at line 54 of file PennMilliSlice.cc.

{
  counter   = header_()->payload_count_counter;
  trigger   = header_()->payload_count_trigger;
  timestamp = header_()->payload_count_timestamp;
  return payloadCount();
}

dune::PennMilliSlice::Header::sequence_id_t dune::PennMilliSlice::sequenceID

(

)

const

Definition at line 24 of file PennMilliSlice.cc.

{
  return header_()->sequence_id;
}

dune::PennMilliSlice::Header::millislice_size_t dune::PennMilliSlice::size

(

)

const

Definition at line 12 of file PennMilliSlice.cc.

{
  return header_()->millislice_size;
}

dune::PennMilliSlice::Header::version_t dune::PennMilliSlice::version

(

)

const

Definition at line 29 of file PennMilliSlice.cc.

{
  return header_()->version;
}

dune::PennMilliSlice::Header::ticks_t dune::PennMilliSlice::widthTicks

(

)

const

Definition at line 39 of file PennMilliSlice.cc.

{
  return header_()->width_in_ticks;
}

Member Data Documentation

uint8_t* dune::PennMilliSlice::buffer_

protected

Definition at line 287 of file PennMilliSlice.hh.

uint8_t* dune::PennMilliSlice::current_payload_

protected

Definition at line 288 of file PennMilliSlice.hh.

uint32_t dune::PennMilliSlice::current_word_id_

protected

Definition at line 289 of file PennMilliSlice.hh.

---

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

• dune-raw-data/dune-raw-data/Overlays/PennMilliSlice.hh
• dune-raw-data/dune-raw-data/Overlays/PennMilliSlice.cc