algo_tpc_huffman Class Reference

#include <algo_tpc_huffman.hh>

Inheritance diagram for algo_tpc_huffman:

List of all members.

Public Member Functions
	algo_tpc_huffman ()
	~algo_tpc_huffman ()
virtual PMT::PMT_WORD	get_word_class (const PMT::word_t word) const
	Override of algo_base::get_word_class method.
virtual bool	process_word (const PMT::word_t word)
	Re-implementation of process_word.
virtual void	reset ()
	Override function to reset the instance.
PMT::word_t	round_diff (PMT::word_t ref_id, PMT::word_t subject_id, PMT::word_t diff) const
	A simple round-diff algorithm for binary words.
virtual bool	is_event_empty ()
	A simple method to inquire if the data storage buffer is currently empty or not.
virtual void	finalize ()
	Function called just after processing word.
void	set_debug_mode (bool doit)
	Run utility: set debug mode. Children class defines what-to-do in debug mode.
void	set_storage_ptr (storage_manager *storage)
	Expects a storage pointer to be provided from a parent class.
virtual void	set_backtrace_mode (size_t nwords=0)
	Run utility: set back-trace mode. One should provide number of words to be stored.
size_t	backtrace_mode () const
	Getter for backtrace mode (returns # words specified to store. 0=no backtrace).
void	backtrace () const
	Function to print out stored words in buffer for back-trace purpose.
void	set_verbosity (MSG::Level level)
	Setter for the verbosity level.
MSG::Level	get_verbosity () const
	Getter for the verbosity level.
const std::string	class_name () const
	Getter for the class name.
Protected Member Functions
virtual void	clear_event ()
	A method to clear event-wise data.
virtual bool	process_event_header (const PMT::word_t word, PMT::word_t &last_word)
	A method to process 32-bit event header word.
virtual bool	process_fem_header (const PMT::word_t word, PMT::word_t &last_word)
	A method to process FEM header word passed from process_word method.
virtual bool	process_ch_word (const PMT::word_t word, PMT::word_t &last_word)
	A method to process 16-bit channel word.
virtual bool	process_fem_last_word (const PMT::word_t word, PMT::word_t &last_word)
	A method to process 32-bit end-of-fem word.
virtual bool	process_event_last_word (const PMT::word_t word, PMT::word_t &last_word)
	A method to process 32-bit end-of-event word.
virtual bool	check_event_quality ()
	Implementation of algo_base::check_event_quality.
bool	store_event ()
	A method to store event-wise data.
bool	decode_ch_word (const PMT::word_t word, PMT::word_t &last_word)
virtual bool	is_compressed (const PMT::word_t word)
virtual bool	decode_fem_header (const PMT::word_t *event_header)
	A method to decode fem header word passed from process_header.
virtual bool	add_huffman_adc (std::vector< UShort_t > &wf, size_t zero_count)
virtual void	init_checker_info ()
	Function to initialize checker information.
Protected Attributes
bool	_search_header
tpc_waveform	_ch_data
tpc_wf_collection *	_event_data
PMT::word_t	_event_header_words [FEM_HEADER_COUNT]
	Event header word holder.
PMT::word_t	_last_word
	Last word processed.
size_t	_event_header_count
	A counter for event header words.
bool	_search_for_next_event
	A run control boolean: skips any action till it finds the new event header.
InfoFEM_t	_header_info
bool	_debug_mode
	Debug mode boolean holder.
bool	_bt_mode
	Back-trace mode boolean holder.
storage_manager *	_storage
	Data storage pointer to be provided by a parent process.
PMT::word_t	_checksum
	data checksum
PMT::word_t	_nwords
	number of data word counts processed
std::deque< PMT::word_t >	_bt_words
	processed words to be stored event-wise for back-trace purpose
size_t	_bt_nwords
	user defined # of words to be temporarily stored in the buffer
bool	_bt_nwords_filled
	run utility boolean to keep a recored of filled buffer
char	_buf [200]
	char buffer for message manipulation
bool	_verbosity [MSG::MSG_TYPE_MAX]
	holder for enabled message levels
MSG::Level	_verbosity_level
	holder for specified verbosity level
std::string	_name
	class name holder
Static Protected Attributes
static const size_t	FEM_HEADER_COUNT = 6
	Number of event header words.
static const size_t	BEAM_REF_CHANNEL = 39
	Defines a reference channel for beamgate.
static const size_t	BEAM_NWORDS = 21
	Defines # of minimum words to identify beamgate event.
static const size_t	FRAME_WIDTH = 8192
	Defines # of ADC samples per readout frame.

---

Detailed Description

Definition at line 7 of file algo_tpc_huffman.hh.

---

Constructor & Destructor Documentation

algo_tpc_huffman::algo_tpc_huffman

(

)

Definition at line 6 of file algo_tpc_huffman.cc.

References decoder_base::_name, and reset().

                                   : algo_tpc_xmit()
{
  _name = "algo_tpc_huffman";
  reset();
}  

algo_tpc_huffman::~algo_tpc_huffman

(

)

[inline]

Definition at line 13 of file algo_tpc_huffman.hh.

{};

---

Member Function Documentation

bool algo_fem_decoder_base::add_huffman_adc	(	std::vector< UShort_t > &	wf,
		size_t	zero_count
	)			[protected, virtual, inherited]

Definition at line 396 of file algo_fem_decoder_base.cc.

Referenced by algo_tpc_xmit::decode_ch_word().

{
//#################################################

  bool status = true;

  switch(zero_count){
    
  case 0:
    wf.push_back( (*(wf.rbegin())) ); break;      
    
  case 1:
    wf.push_back( (*(wf.rbegin())) -1 ); break;
    
  case 2:
    wf.push_back( (*(wf.rbegin())) +1 ); break;
    
  case 3:
    wf.push_back( (*(wf.rbegin())) -2 ); break;
    
  case 4:
    wf.push_back( (*(wf.rbegin())) +2 ); break;
    
  case 5:
    wf.push_back( (*(wf.rbegin())) -3 ); break;
    
  case 6:
    wf.push_back( (*(wf.rbegin())) +3 ); break;
    
  default:

    std::cout<<zero_count<<std::endl;
    
    status = false;
  }
  
  return status;

}

void algo_base::backtrace

(

)

const [inline, inherited]

Function to print out stored words in buffer for back-trace purpose.

Definition at line 82 of file algo_base.hh.

References algo_base::_bt_words, Message::send(), and MSG::WARNING.

Referenced by process_word(), and algo_fem_decoder_base::process_word().

  {
    Message::send(MSG::WARNING,__FUNCTION__,"Dumping a backtrace...");
    int ctr=1;
    for(std::deque<PMT::word_t>::const_iterator iter(_bt_words.begin());
    iter!=_bt_words.end();
    ++iter) {
      printf("%08x ",(*iter));
      if(ctr%8==0 && ctr) std::cout<<std::endl;
      ctr++;
    }
    std::cout<<std::endl<<std::endl;
  };

size_t algo_base::backtrace_mode

(

)

const [inline, inherited]

Getter for backtrace mode (returns # words specified to store. 0=no backtrace).

Definition at line 71 of file algo_base.hh.

References algo_base::_bt_nwords.

{return _bt_nwords;};

bool algo_tpc_xmit::check_event_quality

(

)

[protected, virtual, inherited]

Implementation of algo_base::check_event_quality.

Reimplemented from algo_fem_decoder_base.

Definition at line 179 of file algo_tpc_xmit.cc.

References algo_base::_checksum, algo_fem_decoder_base::_header_info, algo_base::_nwords, MSG::ERROR, and Message::send().

Referenced by algo_tpc_xmit::store_event().

                                       {
//#########################################################

  bool status = true;

  // Check if _checksum and _nwords agrees with that of event header.
  //if(_nwords != _header_info.nwords) {
  _nwords-=1;
  if(_nwords!=_header_info.nwords){

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Disagreement on nwords: counted=%u, expected=%u",_nwords,_header_info.nwords));

    status = false;

  }

  //if(_checksum != _header_info.checksum) {
  if((_checksum & 0xffffff) !=_header_info.checksum){

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Disagreement on checksum: summed=%x, expected=%x",_checksum,_header_info.checksum));

    status = false;

  }

  return status;

}

const std::string decoder_base::class_name

(

)

const [inline, inherited]

Getter for the class name.

Definition at line 46 of file decoder_base.hh.

References decoder_base::_name.

{return _name;};

void algo_tpc_huffman::clear_event

(

)

[protected, virtual]

A method to clear event-wise data.

Reimplemented from algo_tpc_xmit.

Definition at line 18 of file algo_tpc_huffman.cc.

References _search_header, and algo_tpc_xmit::clear_event().

Referenced by process_word().

                                   {

  _search_header = false;

  algo_tpc_xmit::clear_event();

}

bool algo_tpc_xmit::decode_ch_word	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, inherited]

Definition at line 333 of file algo_tpc_xmit.cc.

References algo_tpc_xmit::_ch_data, algo_fem_decoder_base::add_huffman_adc(), MSG::ERROR, algo_tpc_xmit::is_compressed(), and Message::send().

Referenced by algo_tpc_xmit::process_ch_word(), and process_ch_word().

{
//#########################################################

  bool status = true;
  // Simply append if it is not compressed
  if( !(is_compressed(word)) ) _ch_data.push_back( (word & 0xfff) );

  else if(!(_ch_data.size())){

    // This is a problem: if huffman coded, then we must have a previous ADC sample
    // as a reference. Raise an error.

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Huffman coded word %x found while the previous was non-ADC word (%x)!",
               word,last_word));
    
    status = false;

  }
  else{

    // Compresed data is in last 15 bit of this word.
    PMT::word_t data = (word & 0x7fff);

    // The compression is based on an extremely simple Huffman encoding.
    // The Huffman tree used here assigns the following values:
    //
    // Value   Code
    //  +3     0000001
    //  +2     00001
    //  +1     001
    //  +0     1
    //  -1     01
    //  -2     0001
    //  -3     000001

    /*
    size_t zero_count     = 0;
    for(size_t index=0; index<15 && status; ++index){

      if( !((data >> index) & 0x1) ) zero_count++;
      else{

    switch(zero_count){
      
    case 0:
      _ch_data.push_back( (*(_ch_data.rbegin())) ); break;    
      
    case 1:
      _ch_data.push_back( (*(_ch_data.rbegin())) -1 ); break;

    case 2:
      _ch_data.push_back( (*(_ch_data.rbegin())) +1 ); break;

    case 3:
      _ch_data.push_back( (*(_ch_data.rbegin())) -2 ); break;

    case 4:
      _ch_data.push_back( (*(_ch_data.rbegin())) +2 ); break;

    case 5:
      _ch_data.push_back( (*(_ch_data.rbegin())) -3 ); break;

    case 6:
      _ch_data.push_back( (*(_ch_data.rbegin())) +3 ); break;

    default:
      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Encountered unexpected number of zeros (=%zu) in the compressed word %x!",
                 zero_count,word));
      status = false;
    };
    
    zero_count=0;
      }
    }
    */

    size_t zero_count = 0;
    bool   non_zero_found = false;
    for(size_t index=0; index<15 && status; ++index){

      if( !((data >> index) & 0x1) )

    zero_count += ( non_zero_found ? 1 : 0 );
    
      else{
    
    if(!non_zero_found) non_zero_found=true;

    else status = add_huffman_adc(_ch_data,zero_count);
    
    if(status) zero_count=0;
      }
    }

    if(zero_count && status){

      status = add_huffman_adc(_ch_data,zero_count);
      
    }    

    if(!status)
      
      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Encountered unexpected number of zeros (=%zu) in the compressed word %x!",
             zero_count,word));
    
  }
  
  return status;

}

bool algo_fem_decoder_base::decode_fem_header

(

const PMT::word_t *

event_header

)

[protected, virtual, inherited]

A method to decode fem header word passed from process_header.

Definition at line 295 of file algo_fem_decoder_base.cc.

References algo_base::_checksum, algo_fem_decoder_base::_header_info, algo_base::_nwords, decoder_base::_verbosity, algo_fem_decoder_base::InfoFEM_t::checksum, algo_fem_decoder_base::InfoFEM_t::clear_event(), MSG::ERROR, algo_fem_decoder_base::InfoFEM_t::event_frame_id, algo_fem_decoder_base::InfoFEM_t::event_id, MSG::INFO, algo_fem_decoder_base::InfoFEM_t::module_address, algo_fem_decoder_base::InfoFEM_t::module_id, algo_fem_decoder_base::InfoFEM_t::nwords, algo_fem_decoder_base::round_diff(), Message::send(), algo_fem_decoder_base::InfoFEM_t::trigger_frame_id, and algo_fem_decoder_base::InfoFEM_t::trigger_timeslice.

Referenced by process_fem_header(), and algo_fem_decoder_base::process_fem_header().

                                                                          {
//#################################################

  bool status=true;
  //
  // Get event information
  //

  // (1) check if the very first 16-bit word is as expected
  if(!( event_header[0] & 0xffff))
    Message::send(MSG::ERROR,"Unexpected first word in event headers!");

  if(!status) return status;

  // Initialize data holder
  _header_info.clear_event();

  // (2) get module address ... lowest 5 of 12 bits
  _header_info.module_address = ( (event_header[0]>>16 & 0xfff)    & 0x1f);

  // (3) get module ID number ... upper 7 bit of 12 bits
  _header_info.module_id      = ( (event_header[0]>>16 & 0xfff)>>5 & 0x7f);

  // (4) get number of 16-bit words to be read in this event.
  // Lower 12 bits of two 16-bit words.
  // The very last "last word for channel info" is not included in this.
  // For later checking purpose, increment by 1.
  _header_info.nwords         = ( (((event_header[1]>>16) & 0xfff) + ((event_header[1] & 0xfff)<<12)));

  // (5) get event ID
  // Lower 12 bits of two 16-bit words.
  _header_info.event_id       = ( (((event_header[2]>>16) & 0xfff) + ((event_header[2] & 0xfff)<<12)));

  // (6) get frame ID
  // Lower 12 bits of two 16-bit words.
  _header_info.event_frame_id = ( (((event_header[3]>>16) & 0xfff) + ((event_header[3] & 0xfff)<<12)));

  // (7) get checksum
  _header_info.checksum       = ( (((event_header[4]>>16) & 0xfff) + ((event_header[4] & 0xfff)<<12)));


#ifdef INCLUDE_EXTRA_HEADER
  _header_info.trigger_frame_id  = ( ((event_header[5] & 0xfff)>>4 & 0xf) +
                     (((_header_info.event_frame_id)>>4)<<4)); 

  // Correct for a roll over
  _header_info.trigger_frame_id  = round_diff(_header_info.event_frame_id, _header_info.trigger_frame_id, 0x7);

  _header_info.trigger_timeslice = ((((event_header[5]>>16) & 0xf)<<8) + (event_header[5] & 0xff));

#endif

  // Report if verbosity is set.
  if(_verbosity[MSG::INFO])
    {
      Message::send(MSG::INFO,Form("Module %d (ID=%d)", _header_info.module_address, _header_info.module_id));
      Message::send(MSG::INFO,Form("Event ID %d",_header_info.event_id));
      Message::send(MSG::INFO,Form("Frame ID %d",_header_info.event_frame_id));
      Message::send(MSG::INFO,Form("Number of Words = %d",_header_info.nwords));
      Message::send(MSG::INFO,Form("Checksum = %x", _header_info.checksum));
      Message::send(MSG::INFO,Form("Trigger Frame %d",_header_info.trigger_frame_id));
      Message::send(MSG::INFO,Form("Trigger Sample %d",_header_info.trigger_timeslice));
    }

  _checksum=0;

  _nwords=0;
              
  return status;
}

virtual void algo_base::finalize

(

)

[inline, virtual, inherited]

Function called just after processing word.

Definition at line 52 of file algo_base.hh.

{};

MSG::Level decoder_base::get_verbosity

(

)

const [inline, inherited]

Getter for the verbosity level.

Definition at line 43 of file decoder_base.hh.

References decoder_base::_verbosity_level.

{return _verbosity_level;};

virtual PMT::PMT_WORD algo_tpc_huffman::get_word_class

(

const PMT::word_t

word

)

const [inline, virtual]

Override of algo_base::get_word_class method.

Reimplemented from algo_tpc_xmit.

Definition at line 16 of file algo_tpc_huffman.hh.

References PMT::CHANNEL_HEADER, PMT::CHANNEL_LAST_WORD, PMT::CHANNEL_WORD, PMT::EVENT_HEADER, PMT::EVENT_LAST_WORD, PMT::FEM_HEADER, PMT::FEM_LAST_WORD, and PMT::UNDEFINED_WORD.

Referenced by process_ch_word(), process_event_header(), process_event_last_word(), process_fem_header(), and process_word().

                                                                        {
    // One of core functions to identify PMT binary word format
    if( word == 0x0 ) return PMT::UNDEFINED_WORD;
    else if( (word & 0xffffffff) == 0xffffffff ) // Unique marker
      return PMT::EVENT_HEADER;
    else if( (word & 0xffffffff) == 0xe0000000 ) // Unique marker
      return PMT::EVENT_LAST_WORD;
    if( (word & 0xffff) == 0xffff )              // Unique marker
      return PMT::FEM_HEADER;
    else if( (word & 0xf000) == 0xf000 )         // Could be ADC word
      return PMT::FEM_HEADER;
    else if( !((word>>15) & 0x1) ) {
      
      if( (word & 0xf000) == 0x0000 )            // Uncompressed ADC word
    return PMT::CHANNEL_WORD;           
      else if( (word & 0xf000) == 0x4000 )       // Channel first word
    return PMT::CHANNEL_HEADER;
      else if( (word & 0xf000) == 0x5000 )       // Channel last word
    return PMT::CHANNEL_LAST_WORD;
      else
    return PMT::UNDEFINED_WORD;              // Undefined
    }
    else if( ((word>>15) & 0x1) ){
      if( (word & 0xffff) == 0xc000 )            // end of FEM word
    return PMT::FEM_LAST_WORD;
      else
    return PMT::CHANNEL_WORD;                // compressed ADC word
    }else
      return PMT::UNDEFINED_WORD;
  };

void algo_base::init_checker_info

(

)

[protected, virtual, inherited]

Function to initialize checker information.

Definition at line 6 of file algo_base.cc.

References algo_base::_checksum, and algo_base::_nwords.

Referenced by algo_slow_readout_decoder::init_event_info(), algo_trig_decoder::reset(), and algo_base::reset().

{
  _checksum=0x0;
  _nwords=0;
}

virtual bool algo_tpc_xmit::is_compressed

(

const PMT::word_t

word

)

[inline, protected, virtual, inherited]

Definition at line 81 of file algo_tpc_xmit.hh.

Referenced by algo_tpc_xmit::decode_ch_word().

{ return ( word & 0xf000 ); };

virtual bool algo_fem_decoder_base::is_event_empty

(

)

[inline, virtual, inherited]

A simple method to inquire if the data storage buffer is currently empty or not.

Implements algo_base.

Definition at line 107 of file algo_fem_decoder_base.hh.

References algo_fem_decoder_base::_header_info, algo_fem_decoder_base::InfoFEM_t::event_id, and PMT::INVALID_WORD.

{ return (_header_info.event_id == PMT::INVALID_WORD);};

bool algo_tpc_huffman::process_ch_word	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process 16-bit channel word.

Reimplemented from algo_tpc_xmit.

Definition at line 276 of file algo_tpc_huffman.cc.

References algo_tpc_xmit::_ch_data, algo_base::_checksum, algo_tpc_xmit::_event_data, algo_fem_decoder_base::_header_info, algo_base::_nwords, decoder_base::_verbosity, PMT::CHANNEL_HEADER, PMT::CHANNEL_LAST_WORD, tpc_waveform::channel_number(), tpc_waveform::clear_data(), MSG::DEBUG, algo_tpc_xmit::decode_ch_word(), MSG::ERROR, PMT::FEM_HEADER, PMT::FEM_LAST_WORD, get_word_class(), MSG::INFO, process_fem_last_word(), Message::send(), tpc_waveform::set_channel_number(), and algo_tpc_xmit::store_event().

Referenced by process_word().

{

  //
  // This function expects either of three kinds:
  // ch header ... marked
  // ch data (adc) ... unmarked
  // ch last word ... marked
  //
  bool status = true;
  PMT::word_t word_class      = get_word_class(word);
  PMT::word_t last_word_class = get_word_class(last_word);

  // Check for zero-padding that is allowed after channel last word
  if(word == 0x0){

    if(get_word_class(last_word)!=PMT::CHANNEL_LAST_WORD){

      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Unexpected Zero-padding found after %x",last_word));
      status = false;
    }else if(_verbosity[MSG::INFO])
     
      Message::send(MSG::INFO,__FUNCTION__,
            Form("Zero-padding found after %x",last_word));
    
    return status;
  }

  switch(word_class){
    
  case PMT::CHANNEL_HEADER:
   
    //
    // Check if the last word was event header or channel last word
    //
    if(last_word_class == PMT::FEM_HEADER ||
       last_word_class == PMT::CHANNEL_LAST_WORD ) {
      
      // New data starts here. 
      // Clear data content & assign channel number.
      _ch_data.clear_data();

      _ch_data.set_channel_number( (word & 0xfff) );
      
      if(_verbosity[MSG::DEBUG])

    Message::send(MSG::DEBUG,__FUNCTION__,
              Form("New channel header: %d",_ch_data.channel_number()));
      
    }else{

      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Unexpected channel header (%x)! Last word = %x",word,last_word));

      status = false;

    }

    break;

  case PMT::CHANNEL_LAST_WORD:{

    // Check channel number is same as the header
    PMT::ch_number_t ch( (word & 0xfff) );
    if(ch == _ch_data.channel_number()) {

      if(_verbosity[MSG::DEBUG])
    
    Message::send(MSG::DEBUG,__FUNCTION__,
              Form("Finished reading %zu samples for Ch %d",
               _ch_data.size(),_ch_data.channel_number()));
      
      // Store
      _event_data->push_back(_ch_data);
      
      _ch_data.clear_data();
      
    }else{

    Message::send(MSG::ERROR,__FUNCTION__,
              Form("Ch. number disagreement! Header: %u ... Last: %u!",
               _ch_data.channel_number(),ch) );
    
    status = false;
    }

    // Attempt to store data if nwords matches with the expected number
    if(status && _nwords == _header_info.nwords){
      _nwords++;
      _checksum += word;
      status = store_event();
    }

    break;
  }
  case PMT::FEM_LAST_WORD:
    
    if(last_word_class == PMT::CHANNEL_LAST_WORD)

      status = process_fem_last_word(word,last_word);

    else status = decode_ch_word(word,last_word);

    break;

  default:

    status = decode_ch_word(word,last_word);
  }

  if(status && _header_info.nwords){
    
    _nwords++;
    _checksum += word;

  }    

  last_word = word;

  return status;
}

bool algo_tpc_huffman::process_event_header	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process 32-bit event header word.

Reimplemented from algo_tpc_xmit.

Definition at line 164 of file algo_tpc_huffman.cc.

References algo_tpc_xmit::_event_data, algo_base::_storage, MSG::ERROR, PMT::EVENT_LAST_WORD, storage_manager::get_data(), get_word_class(), Message::send(), and DATA_STRUCT::TPC_WF_COLLECTION.

Referenced by process_word().

{
  bool status = true;

  if(!_event_data)

    _event_data = (tpc_wf_collection*)(_storage->get_data(DATA_STRUCT::TPC_WF_COLLECTION));

  else if(get_word_class(last_word)!=PMT::EVENT_LAST_WORD){

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Unexpected event header (%x) with the previous word %x!",word,last_word));

    status = false;

  }

  last_word = word;

  return status;
}

bool algo_tpc_huffman::process_event_last_word	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process 32-bit end-of-event word.

Store event @ this point.

Reimplemented from algo_tpc_xmit.

Definition at line 230 of file algo_tpc_huffman.cc.

References algo_fem_decoder_base::_header_info, PMT::CHANNEL_LAST_WORD, MSG::ERROR, get_word_class(), PMT::INVALID_WORD, and Message::send().

Referenced by process_word().

{
  bool status = true;
  
  //
  // Make an explicit check.
  // Previous word should be the channel last word
  // By this point data should be saved and _header_info should be cleared.
  //
  PMT::word_t last_word_class = get_word_class(last_word);

  if(last_word_class != PMT::CHANNEL_LAST_WORD) {

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Unexpected event last word (%x) with the previous word %x!",word,last_word));

    status = false;

  }else if(_header_info.event_id!=PMT::INVALID_WORD){

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("End of event (%x) ... but buffer holds data for event %d!",word,_header_info.event_id));

    status = false;

  }

  last_word = word;

  return status;
}

bool algo_tpc_huffman::process_fem_header	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process FEM header word passed from process_word method.

Reimplemented from algo_fem_decoder_base.

Definition at line 187 of file algo_tpc_huffman.cc.

References algo_fem_decoder_base::_event_header_count, algo_fem_decoder_base::_event_header_words, PMT::CHANNEL_LAST_WORD, algo_fem_decoder_base::decode_fem_header(), MSG::ERROR, PMT::EVENT_HEADER, PMT::FEM_HEADER, algo_fem_decoder_base::FEM_HEADER_COUNT, get_word_class(), and Message::send().

Referenced by process_word().

{
  bool status = true;
  //
  // This function must be called for true FEM headers.
  // Hence we implement a strict check to make sure this is FEM header
  //
  PMT::word_t last_word_class = get_word_class(last_word);

  if(last_word_class != PMT::EVENT_HEADER &&
     last_word_class != PMT::FEM_HEADER &&
     last_word_class != PMT::CHANNEL_LAST_WORD) {

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Unexpected FEM header (%x) with the previous word %x!",word,last_word));

    status = false;
  }else if(get_word_class(word>>16)!=PMT::FEM_HEADER) {

    // Event header should come as a 32-bit word which is a pair of two 16-bit header words.
    // The first 16-bit is already checked by this point. Check the second part.

    Message::send(MSG::ERROR,__FUNCTION__,Form("Found an odd event header word: %x",word));
      
    status = false;    
  }else{

    _event_header_words[_event_header_count] = word;

    _event_header_count++;

    if(_event_header_count == FEM_HEADER_COUNT)

      status = decode_fem_header(_event_header_words);
  
  }

  last_word = word;

  return status;
}

bool algo_tpc_huffman::process_fem_last_word	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process 32-bit end-of-fem word.

Nothing to be done really.

Reimplemented from algo_tpc_xmit.

Definition at line 263 of file algo_tpc_huffman.cc.

References MSG::ERROR, and Message::send().

Referenced by process_ch_word().

{
  //
  // This function should not be used as of now
  //
  Message::send(MSG::ERROR,__FUNCTION__,
        "This function should not be called...");

  last_word = word;
  return false;
}

bool algo_tpc_huffman::process_word

(

const PMT::word_t

word

)

[virtual]

Re-implementation of process_word.

All machinaries based on word maker are useless in case of huffman coded TPC data because an entire 15 bits are used for compressed data bits.

Reimplemented from algo_fem_decoder_base.

Definition at line 26 of file algo_tpc_huffman.cc.

References algo_base::_bt_mode, algo_base::_bt_nwords, algo_base::_bt_nwords_filled, algo_base::_bt_words, algo_base::_debug_mode, algo_tpc_xmit::_event_data, algo_fem_decoder_base::_header_info, algo_fem_decoder_base::_last_word, algo_base::_nwords, algo_fem_decoder_base::_search_for_next_event, algo_base::backtrace(), clear_event(), PMT::EVENT_HEADER, PMT::EVENT_LAST_WORD, PMT::FEM_HEADER, get_word_class(), process_ch_word(), process_event_header(), process_event_last_word(), process_fem_header(), Message::send(), algo_tpc_xmit::store_event(), and MSG::WARNING.

                                                        {

  // If in back_trace mode, add this word in record
  if(_bt_mode){
    
    // Check if buffer is filled
    if(!_bt_nwords_filled)
      _bt_nwords_filled = (_bt_nwords == _bt_words.size());

    // If filled, remove the oldest element
    if(_bt_nwords_filled)
      _bt_words.pop_front();

    // Add new word
    _bt_words.push_back(word);

  }

  if(word==0x0)

    return true;

  bool status = true;
  PMT::word_t word_class = get_word_class(word);
  PMT::word_t last_word_class = get_word_class(_last_word);

  if( _search_for_next_event ) {
    
    if( !(word_class == PMT::EVENT_HEADER && 
      last_word_class == PMT::EVENT_LAST_WORD ) ) {
      
      _last_word = word;
      return status;
    }

  }



  //
  // In case of huffman coded data stream, uniquely marked
  // words are only:
  // (*) event header
  // (*) event last word 
  // (*) channel header
  // (*) channel last word
  //
  switch(word_class){

  case PMT::EVENT_HEADER:

    if( (last_word_class == PMT::EVENT_LAST_WORD && !(_header_info.nwords)) || !(_event_data)) {
      
      _search_for_next_event = false;
      
      status = process_event_header(word,_last_word);
    }
    else{

      PMT::word_t first_word  = (word & 0xffff);
      PMT::word_t second_word = (word >> 16);
      
      status = process_ch_word(first_word,_last_word);

      if(status) status = process_ch_word(second_word,_last_word);

    }

    break;

  case PMT::FEM_HEADER:

    if(_nwords && _nwords == _header_info.nwords){

      _nwords++;
      status = store_event();

    }

    if(status){ 

      if(!(_header_info.nwords))

    status = process_fem_header(word,_last_word);
      
      else{

    PMT::word_t first_word  = (word & 0xffff);
    PMT::word_t second_word = (word >> 16);
    
    status = process_ch_word(first_word,_last_word);
    
    if(status) status = process_ch_word(second_word,_last_word);
    
      }
    }

    break;
    
  case PMT::EVENT_LAST_WORD:

    //if(last_word_class == PMT::CHANNEL_LAST_WORD){

    status = process_event_last_word(word,_last_word);
    break;
    //}

  default:

    PMT::word_t first_word  = (word & 0xffff);
    PMT::word_t second_word = (word >> 16);
    
    status = process_ch_word(first_word,_last_word);
    
    if(status) status = process_ch_word(second_word,_last_word);

  }

  if(!status){

    if(_bt_mode)
      backtrace();

    clear_event();

    if(_debug_mode){

      Message::send(MSG::WARNING,__FUNCTION__,"DEBUG MODE => Continue to next event...");
      
      _search_for_next_event = true;

    }

  }

  return status;
}

void algo_tpc_huffman::reset

(

)

[virtual]

Override function to reset the instance.

Reimplemented from algo_tpc_xmit.

Definition at line 12 of file algo_tpc_huffman.cc.

References algo_tpc_xmit::reset().

Referenced by algo_tpc_huffman().

                             {

  algo_tpc_xmit::reset();

}

PMT::word_t algo_fem_decoder_base::round_diff	(	PMT::word_t	ref_id,
		PMT::word_t	subject_id,
		PMT::word_t	diff
	)			const [inherited]

A simple round-diff algorithm for binary words.

Definition at line 368 of file algo_fem_decoder_base.cc.

Referenced by algo_pmt_xmit::decode_ch_word(), and algo_fem_decoder_base::decode_fem_header().

{
  // Used to recover pmt/trigger frame id from roll over effect.
  // One can test this by simply calling this function.
  // For instance, to test the behavior for a roll-over of 0x7 ...
  //
  // > root
  // root[0] gSystem->Load("libDecoder")
  // root[1] algo_slow_readout_decoder k
  // root [6] k.get_pmt_frame(583,584,0x7)
  // (const unsigned int)584
  // root [7] k.get_pmt_frame(584,583,0x7)
  // (const unsigned int)583
  //
  // I think this implementation works. ... Aug. 12 2013
  if( (subject_id > ref_id) && ((subject_id-ref_id) >= diff) )
    return subject_id - (diff+1);
  else if( (ref_id > subject_id) && ((ref_id-subject_id) >= diff) )    
    return subject_id + (diff+1);
  else
    return subject_id;

}

virtual void algo_base::set_backtrace_mode

(

size_t

nwords = 0

)

[inline, virtual, inherited]

Run utility: set back-trace mode. One should provide number of words to be stored.

Definition at line 65 of file algo_base.hh.

References algo_base::_bt_mode, and algo_base::_bt_nwords.

Referenced by main().

                                                  {
    _bt_nwords=nwords;
    _bt_mode=(bool)(nwords);
  };

void algo_base::set_debug_mode

(

bool

doit

)

[inline, inherited]

Run utility: set debug mode. Children class defines what-to-do in debug mode.

Definition at line 59 of file algo_base.hh.

References algo_base::_debug_mode.

Referenced by decoder_manager::initialize().

{_debug_mode=doit;};

void algo_base::set_storage_ptr

(

storage_manager *

storage

)

[inline, inherited]

Expects a storage pointer to be provided from a parent class.

Definition at line 62 of file algo_base.hh.

References algo_base::_storage.

Referenced by decoder_manager::initialize().

{_storage=storage;};

void decoder_base::set_verbosity

(

MSG::Level

level

)

[inherited]

Setter for the verbosity level.

Reimplemented in ana_processor.

Definition at line 11 of file decoder_base.cc.

References decoder_base::_verbosity, decoder_base::_verbosity_level, MSG::DEBUG, MSG::ERROR, MSG::INFO, MSG::MSG_TYPE_MAX, MSG::NORMAL, and MSG::WARNING.

Referenced by algo_slow_readout_decoder::algo_slow_readout_decoder(), compare_content(), decoder_base::decoder_base(), decoder_manager::decoder_manager(), decoder_manager::initialize(), main(), xmit_event_search::run(), bin_word_search::run(), and ana_processor::set_verbosity().

                                              {

  _verbosity_level=level;

  for(size_t i=(size_t)(MSG::DEBUG); i<(size_t)(MSG::MSG_TYPE_MAX); ++i)
    _verbosity[i]=false;

  switch(level){
  case MSG::DEBUG:
    _verbosity[MSG::DEBUG]=true;
  case MSG::INFO:
    _verbosity[MSG::INFO]=true;
  case MSG::NORMAL:
    _verbosity[MSG::NORMAL]=true;
  case MSG::WARNING:
    _verbosity[MSG::WARNING]=true;
  case MSG::ERROR:
    _verbosity[MSG::ERROR]=true;
  case MSG::MSG_TYPE_MAX:
    break;
  }

}

bool algo_tpc_xmit::store_event

(

)

[protected, virtual, inherited]

A method to store event-wise data.

Implements algo_fem_decoder_base.

Definition at line 291 of file algo_tpc_xmit.cc.

References algo_tpc_xmit::_event_data, algo_fem_decoder_base::_header_info, algo_base::_storage, decoder_base::_verbosity, algo_tpc_xmit::check_event_quality(), algo_tpc_xmit::clear_event(), MSG::ERROR, tpc_wf_collection::event_id(), MSG::INFO, storage_manager::next_event(), Message::send(), tpc_wf_collection::set_checksum(), tpc_wf_collection::set_event_frame_id(), tpc_wf_collection::set_event_id(), tpc_wf_collection::set_module_address(), tpc_wf_collection::set_module_id(), tpc_wf_collection::set_nwords(), tpc_wf_collection::set_trigger_frame_id(), and tpc_wf_collection::set_trigger_timeslice().

Referenced by process_ch_word(), algo_tpc_xmit::process_event_header(), and process_word().

                               {
//#########################################################
 
  bool status = check_event_quality();

  // Store if condition is satisfied
  if(status) {

    if(_verbosity[MSG::INFO]){

      Message::send(MSG::INFO,__FUNCTION__,
            Form("Storing event %u with %zu channel entries...",
             _event_data->event_id(), _event_data->size()));

    }

    _event_data->set_module_address    ( _header_info.module_address    );
    _event_data->set_module_id         ( _header_info.module_id         );
    _event_data->set_event_id          ( _header_info.event_id          );
    _event_data->set_event_frame_id    ( _header_info.event_frame_id    );
    _event_data->set_trigger_frame_id  ( _header_info.trigger_frame_id  );
    _event_data->set_trigger_timeslice ( _header_info.trigger_timeslice );
    _event_data->set_nwords            ( _header_info.nwords            );
    _event_data->set_checksum          ( _header_info.checksum          );

    status = _storage->next_event();

  }else{
    
    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Skipping to store event %d...",_header_info.event_id));

    status = false;
    
  }

  clear_event();

  return status;
}

---

Member Data Documentation

bool algo_base::_bt_mode [protected, inherited]

Back-trace mode boolean holder.

Definition at line 109 of file algo_base.hh.

Referenced by algo_base::algo_base(), algo_trig_decoder::process_word(), process_word(), algo_slow_readout_decoder::process_word(), algo_fem_decoder_base::process_word(), and algo_base::set_backtrace_mode().

size_t algo_base::_bt_nwords [protected, inherited]

user defined # of words to be temporarily stored in the buffer

Definition at line 133 of file algo_base.hh.

Referenced by algo_base::algo_base(), algo_base::backtrace_mode(), algo_trig_decoder::process_word(), process_word(), algo_slow_readout_decoder::process_word(), algo_fem_decoder_base::process_word(), and algo_base::set_backtrace_mode().

bool algo_base::_bt_nwords_filled [protected, inherited]

run utility boolean to keep a recored of filled buffer

Definition at line 134 of file algo_base.hh.

Referenced by algo_base::algo_base(), algo_trig_decoder::process_word(), process_word(), algo_slow_readout_decoder::process_word(), and algo_fem_decoder_base::process_word().

std::deque<PMT::word_t> algo_base::_bt_words [protected, inherited]

processed words to be stored event-wise for back-trace purpose

Definition at line 132 of file algo_base.hh.

Referenced by algo_base::backtrace(), algo_trig_decoder::process_word(), process_word(), algo_slow_readout_decoder::process_word(), and algo_fem_decoder_base::process_word().

char decoder_base::_buf[200] [protected, inherited]

char buffer for message manipulation

Definition at line 46 of file decoder_base.hh.

Referenced by reco_wf::analyze(), pulse_viewer::analyze(), algo_slow_readout_decoder::check_event_quality(), storage_manager::close(), bin_io_handler::close(), decoder_manager::decode(), algo_slow_readout_decoder::decode_ch_word(), algo_pmt_xmit::decode_ch_word(), algo_slow_readout_decoder::decode_event_header(), pulse_viewer::get_waveform(), ana_processor::initialize(), pulse_viewer::next_pulse(), storage_manager::open(), bin_io_handler::open(), storage_manager::prepare_tree(), pulse_viewer::previous_pulse(), algo_slow_readout_decoder::print_adc_values(), algo_tpc_xmit::process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), algo_fem_decoder_base::process_fem_header(), algo_xmit_decoder::process_header(), algo_slow_readout_decoder::process_header(), algo_slow_readout_decoder::process_word(), bin_io_handler::read_multi_word(), bin_io_handler::read_word(), and ana_processor::run().

tpc_waveform algo_tpc_xmit::_ch_data [protected, inherited]

Definition at line 108 of file algo_tpc_xmit.hh.

Referenced by algo_tpc_xmit::clear_event(), algo_tpc_xmit::decode_ch_word(), algo_tpc_xmit::process_ch_word(), process_ch_word(), and algo_tpc_xmit::reset().

PMT::word_t algo_base::_checksum [protected, inherited]

data checksum

Definition at line 126 of file algo_base.hh.

Referenced by algo_tpc_xmit::check_event_quality(), algo_slow_readout_decoder::check_event_quality(), algo_pmt_xmit::check_event_quality(), algo_slow_readout_decoder::decode_event_header(), algo_fem_decoder_base::decode_fem_header(), algo_base::init_checker_info(), algo_tpc_xmit::process_ch_word(), process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), and algo_trig_decoder::process_word().

bool algo_base::_debug_mode [protected, inherited]

Debug mode boolean holder.

Definition at line 108 of file algo_base.hh.

Referenced by algo_base::algo_base(), algo_slow_readout_decoder::process_ch_word(), algo_fem_decoder_base::process_fem_header(), algo_slow_readout_decoder::process_header(), algo_trig_decoder::process_word(), process_word(), algo_slow_readout_decoder::process_word(), algo_fem_decoder_base::process_word(), and algo_base::set_debug_mode().

tpc_wf_collection* algo_tpc_xmit::_event_data [protected, inherited]

Definition at line 110 of file algo_tpc_xmit.hh.

Referenced by algo_tpc_xmit::clear_event(), algo_tpc_xmit::process_ch_word(), process_ch_word(), algo_tpc_xmit::process_event_header(), process_event_header(), process_word(), algo_tpc_xmit::reset(), and algo_tpc_xmit::store_event().

size_t algo_fem_decoder_base::_event_header_count [protected, inherited]

A counter for event header words.

Definition at line 171 of file algo_fem_decoder_base.hh.

Referenced by algo_fem_decoder_base::clear_event(), process_fem_header(), algo_fem_decoder_base::process_fem_header(), and algo_fem_decoder_base::reset().

PMT::word_t algo_fem_decoder_base::_event_header_words[FEM_HEADER_COUNT] [protected, inherited]

Event header word holder.

Definition at line 165 of file algo_fem_decoder_base.hh.

Referenced by process_fem_header(), algo_fem_decoder_base::process_fem_header(), and algo_fem_decoder_base::reset().

InfoFEM_t algo_fem_decoder_base::_header_info [protected, inherited]

Definition at line 174 of file algo_fem_decoder_base.hh.

Referenced by algo_tpc_xmit::check_event_quality(), algo_pmt_xmit::check_event_quality(), algo_fem_decoder_base::clear_event(), algo_fem_decoder_base::decode_fem_header(), algo_fem_decoder_base::is_event_empty(), process_ch_word(), process_event_last_word(), process_word(), algo_fem_decoder_base::process_word(), algo_tpc_xmit::store_event(), and algo_pmt_xmit::store_event().

PMT::word_t algo_fem_decoder_base::_last_word [protected, inherited]

Last word processed.

Definition at line 170 of file algo_fem_decoder_base.hh.

Referenced by process_word(), algo_fem_decoder_base::process_word(), and algo_fem_decoder_base::reset().

std::string decoder_base::_name [protected, inherited]

class name holder

Definition at line 53 of file decoder_base.hh.

Referenced by algo_base::algo_base(), algo_fem_decoder_base::algo_fem_decoder_base(), algo_fixed_window::algo_fixed_window(), algo_slow_readout_decoder::algo_slow_readout_decoder(), algo_threshold::algo_threshold(), algo_tpc_huffman(), algo_trig_decoder::algo_trig_decoder(), ana_base::ana_base(), ana_processor::ana_processor(), beamgate_debugger::beamgate_debugger(), bin_io_handler::bin_io_handler(), decoder_base::class_name(), led_pulse_analyzer::led_pulse_analyzer(), led_pulse_selector::led_pulse_selector(), pmt_slow_encoder::pmt_slow_encoder(), pmtbaseline::pmtbaseline(), pmtbaseline_ana::pmtbaseline_ana(), preco_algo_base::preco_algo_base(), pulse_analyzer::pulse_analyzer(), pulse_reco::pulse_reco(), pulse_selector_base::pulse_selector_base(), pulse_selector_simple::pulse_selector_simple(), pulse_viewer::pulse_viewer(), reco_wf::reco_wf(), storage_manager::storage_manager(), and waveform_sampler::waveform_sampler().

PMT::word_t algo_base::_nwords [protected, inherited]

number of data word counts processed

Definition at line 127 of file algo_base.hh.

Referenced by algo_tpc_xmit::check_event_quality(), algo_slow_readout_decoder::check_event_quality(), algo_pmt_xmit::check_event_quality(), algo_slow_readout_decoder::decode_event_header(), algo_fem_decoder_base::decode_fem_header(), algo_base::init_checker_info(), algo_tpc_xmit::process_ch_word(), process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), algo_pmt_xmit::process_fem_last_word(), algo_trig_decoder::process_word(), and process_word().

bool algo_fem_decoder_base::_search_for_next_event [protected, inherited]

A run control boolean: skips any action till it finds the new event header.

Definition at line 173 of file algo_fem_decoder_base.hh.

Referenced by process_word(), algo_fem_decoder_base::process_word(), and algo_fem_decoder_base::reset().

bool algo_tpc_huffman::_search_header [protected]

Definition at line 78 of file algo_tpc_huffman.hh.

Referenced by clear_event().

storage_manager* algo_base::_storage [protected, inherited]

Data storage pointer to be provided by a parent process.

Definition at line 121 of file algo_base.hh.

Referenced by algo_base::algo_base(), algo_slow_readout_decoder::process_ch_word(), algo_tpc_xmit::process_event_header(), process_event_header(), algo_pmt_xmit::process_event_header(), algo_trig_decoder::process_word(), algo_slow_readout_decoder::process_word(), algo_base::reset(), algo_base::set_storage_ptr(), algo_tpc_xmit::store_event(), and algo_pmt_xmit::store_event().

bool decoder_base::_verbosity[MSG::MSG_TYPE_MAX] [protected, inherited]

holder for enabled message levels

Definition at line 51 of file decoder_base.hh.

Referenced by reco_wf::analyze(), algo_slow_readout_decoder::check_event_quality(), storage_manager::close(), decoder_manager::decode(), algo_slow_readout_decoder::decode_ch_word(), algo_pmt_xmit::decode_ch_word(), algo_slow_readout_decoder::decode_event_header(), algo_fem_decoder_base::decode_fem_header(), algo_trig_decoder::decode_trigger_words(), decoder_manager::finalize(), beamgate_debugger::finalize(), ana_processor::finalize(), decoder_manager::initialize(), beamgate_debugger::initialize(), ana_processor::initialize(), storage_manager::open(), beamgate_debugger::prepare_histo(), storage_manager::prepare_tree(), algo_tpc_xmit::process_ch_word(), process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), algo_tpc_xmit::process_event_last_word(), algo_pmt_xmit::process_event_last_word(), algo_fem_decoder_base::process_fem_header(), algo_pmt_xmit::process_fem_last_word(), algo_xmit_decoder::process_header(), algo_slow_readout_decoder::process_header(), algo_fem_decoder_base::process_word(), bin_io_handler::read_multi_word(), storage_manager::reset(), beamgate_debugger::reset(), ana_processor::reset(), decoder_manager::run(), ana_processor::run(), decoder_base::set_verbosity(), algo_tpc_xmit::store_event(), and algo_pmt_xmit::store_event().

MSG::Level decoder_base::_verbosity_level [protected, inherited]

holder for specified verbosity level

Definition at line 52 of file decoder_base.hh.

Referenced by pulse_viewer::analyze(), decoder_base::get_verbosity(), pulse_viewer::initialize(), decoder_manager::initialize(), ana_processor::initialize(), bin_io_handler::read_multi_word(), bin_io_handler::read_word(), and decoder_base::set_verbosity().

const size_t algo_base::BEAM_NWORDS = 21 [static, protected, inherited]

Defines # of minimum words to identify beamgate event.

Definition at line 115 of file algo_base.hh.

Referenced by algo_slow_readout_decoder::apply_beamgate_correction(), and algo_slow_readout_decoder::store_ch_data().

const size_t algo_base::BEAM_REF_CHANNEL = 39 [static, protected, inherited]

Defines a reference channel for beamgate.

Definition at line 114 of file algo_base.hh.

Referenced by algo_slow_readout_decoder::store_ch_data().

const size_t algo_fem_decoder_base::FEM_HEADER_COUNT = 6 [static, protected, inherited]

Number of event header words.

Definition at line 159 of file algo_fem_decoder_base.hh.

Referenced by process_fem_header(), algo_fem_decoder_base::process_fem_header(), and algo_fem_decoder_base::reset().

const size_t algo_base::FRAME_WIDTH = 8192 [static, protected, inherited]

Defines # of ADC samples per readout frame.

Definition at line 116 of file algo_base.hh.

Referenced by algo_slow_readout_decoder::apply_beamgate_correction().

---

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

• algo_tpc_huffman.hh
• algo_tpc_huffman.cc

---