algo_tpc_xmit Class Reference
[Algorithm, Algorithm]

Implementation for TPC XMIT data stream based on algo_fem_decoder_base class. More...

#include <algo_tpc_xmit.hh>

Inheritance diagram for algo_tpc_xmit:

List of all members.

Public Member Functions
	algo_tpc_xmit ()
	Default constructor.
virtual	~algo_tpc_xmit ()
	Default destructor.
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)
	Implementation of algo_base::process_word.
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 bool	check_event_quality ()
	Implementation of algo_base::check_event_quality.
virtual void	clear_event ()
	A method to clear event-wise data.
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 void	reset ()
	Override function to reset the instance.
virtual bool	is_compressed (const PMT::word_t word)
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_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	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	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
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

Implementation for TPC XMIT data stream based on algo_fem_decoder_base class.

There're lots of common things among PMT/TPC XMIT decoder, and ideally this class inherits from that of PMT. This is purely historical reason that I decided to develop this as a separate class w/o making such inheritance. It turned out PMT has a lot more information (not data volume) than TPC. It does not make sense to let TPC decoder class inherit from PMT decoder class (as TPC decoder is simpler). This calls for a design review. For now, I omit this design issue and go ahead to implement a working version of tpc decoder.

It expects a stream of 32-bit words (ordered) to be fed into process_word method. This class takes care of decoding & grouping channel/event wise data & storing them.

Definition at line 36 of file algo_tpc_xmit.hh.

---

Constructor & Destructor Documentation

algo_tpc_xmit::algo_tpc_xmit

(

)

Default constructor.

Definition at line 7 of file algo_tpc_xmit.cc.

References reset().

  : algo_fem_decoder_base() 
{
//#########################################

  reset();

}

virtual algo_tpc_xmit::~algo_tpc_xmit

(

)

[inline, virtual]

Default destructor.

Definition at line 44 of file algo_tpc_xmit.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 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 algo_tpc_huffman::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]

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 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_xmit::clear_event

(

)

[protected, virtual]

A method to clear event-wise data.

Reimplemented from algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 279 of file algo_tpc_xmit.cc.

References _ch_data, _event_data, tpc_wf_collection::clear_data(), and algo_fem_decoder_base::clear_event().

Referenced by algo_tpc_huffman::clear_event(), process_ch_word(), and store_event().

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

  algo_fem_decoder_base::clear_event();

  _event_data->clear_data();

  _ch_data.clear();

}

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

Definition at line 333 of file algo_tpc_xmit.cc.

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

Referenced by process_ch_word(), and algo_tpc_huffman::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 algo_tpc_huffman::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_xmit::get_word_class

(

const PMT::word_t

word

)

const [inline, virtual]

Override of algo_base::get_word_class method.

Reimplemented from algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 48 of file algo_tpc_xmit.hh.

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

Referenced by process_ch_word(), and process_event_header().

                                                                        {
    // One of core functions to identify PMT binary word format
    if( (word & 0xffffffff) == 0xffffffff )
      return PMT::EVENT_HEADER;
    else if( (word & 0xffffffff) == 0xe0000000 )
      return PMT::EVENT_LAST_WORD;
    if( (word & 0xffff) == 0xffff )
      return PMT::FEM_HEADER;
    else if( (word & 0xf000) == 0xf000 )
      return PMT::FEM_HEADER;
    else if( (word & 0xf000) == 0x4000 )
      return PMT::CHANNEL_HEADER;
    else if( (word & 0xf000) == 0x0000 ||
         (word & 0xf000) == 0x8000   )
      return PMT::CHANNEL_WORD;
    else if( (word & 0xf000) == 0x5000 )
      return PMT::CHANNEL_LAST_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]

Definition at line 81 of file algo_tpc_xmit.hh.

Referenced by 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_xmit::process_ch_word	(	const PMT::word_t	word,
		PMT::word_t &	last_word
	)			[protected, virtual]

A method to process 16-bit channel word.

Implements algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 29 of file algo_tpc_xmit.cc.

References decoder_base::_buf, _ch_data, algo_base::_checksum, _event_data, algo_base::_nwords, decoder_base::_verbosity, PMT::CHANNEL_HEADER, PMT::CHANNEL_LAST_WORD, tpc_waveform::channel_number(), PMT::CHANNEL_WORD, tpc_waveform::clear_data(), clear_event(), MSG::DEBUG, decode_ch_word(), MSG::ERROR, PMT::EVENT_HEADER, PMT::EVENT_LAST_WORD, PMT::FEM_FIRST_WORD, PMT::FEM_HEADER, PMT::FEM_LAST_WORD, get_word_class(), Message::send(), tpc_waveform::set_channel_number(), and PMT::UNDEFINED_WORD.

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

  bool status=true;

  if(_verbosity[MSG::DEBUG]){
    sprintf(_buf,"Processing ch-word: %x",word);
    Message::send(MSG::DEBUG,__FUNCTION__,_buf);
  }

  PMT::PMT_WORD word_class=get_word_class(word);
  PMT::PMT_WORD last_word_class=get_word_class(last_word);
  
  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 if the last word was channel word
    //
    if(last_word_class == PMT::CHANNEL_WORD) {

      // Check if the channel number in this ch-last-word agrees with that in 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;

      }

    }
    else{

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

    }

    break;

  case PMT::CHANNEL_WORD:

    //
    // Check if the last word was channel header or channel adc word
    //
    if(last_word_class == PMT::CHANNEL_HEADER ||
       last_word_class == PMT::CHANNEL_WORD){

      status = decode_ch_word(word,last_word);

    }else{

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

      status = false;

    }

    break;

  case PMT::EVENT_LAST_WORD:
  case PMT::FEM_LAST_WORD:
  case PMT::UNDEFINED_WORD:
  case PMT::EVENT_HEADER:
  case PMT::FEM_HEADER:
  case PMT::FEM_FIRST_WORD:

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Unexpected word found while channel word processing: %x",word));

    status = false;

    break;
  }

  // If processing of this word is successful, add it to the checksum
  if(status) {

    _nwords++;
    _checksum += word;
    //std::cout<<_nwords<<" ... "<<_checksum<<std::endl;
  }else{

    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Failed processing channel word %x (previous=%x)",word,last_word));

    clear_event();
  }

  if(word_class != PMT::UNDEFINED_WORD)

    last_word = word;

  return status;
}

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

A method to process 32-bit event header word.

Implements algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 213 of file algo_tpc_xmit.cc.

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

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

  bool status = true;

  if(!_event_data)

    _event_data = (tpc_wf_collection*)(_storage->get_data(DATA_STRUCT::TPC_WF_COLLECTION));
  
  if(get_word_class(last_word)==PMT::EVENT_LAST_WORD) {
    
    // Attempt to store data
    
    status = store_event();
  }else if(last_word != PMT::INVALID_WORD){

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

    status = false;

  }

  last_word = word;

  return status;

}

bool algo_tpc_xmit::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.

Implements algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 260 of file algo_tpc_xmit.cc.

References decoder_base::_verbosity, MSG::INFO, and Message::send().

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

  if(_verbosity[MSG::INFO]){
      
    Message::send(MSG::INFO,__FUNCTION__,
          Form("End of event word: %x...",word));
    
  }

  last_word = word;

  return true;
}

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

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

Reimplemented in algo_tpc_huffman.

Definition at line 185 of file algo_fem_decoder_base.cc.

References decoder_base::_buf, algo_base::_debug_mode, algo_fem_decoder_base::_event_header_count, algo_fem_decoder_base::_event_header_words, decoder_base::_verbosity, PMT::CHANNEL_HEADER, PMT::CHANNEL_LAST_WORD, PMT::CHANNEL_WORD, algo_fem_decoder_base::clear_event(), MSG::DEBUG, algo_fem_decoder_base::decode_fem_header(), MSG::ERROR, PMT::EVENT_HEADER, PMT::EVENT_LAST_WORD, PMT::FEM_FIRST_WORD, PMT::FEM_HEADER, algo_fem_decoder_base::FEM_HEADER_COUNT, PMT::FEM_LAST_WORD, algo_fem_decoder_base::get_word_class(), Message::send(), algo_fem_decoder_base::store_event(), PMT::UNDEFINED_WORD, and MSG::WARNING.

Referenced by algo_fem_decoder_base::process_word().

                                                                                         {
//#################################################
  
  bool status=true;
  //
  // Check if this is an event header word or not
  //
  PMT::PMT_WORD word_class=get_word_class(word);
  if(_verbosity[MSG::DEBUG]){
    sprintf(_buf,"Processing Header: %x",word);
    Message::send(MSG::DEBUG,__FUNCTION__,_buf);
  }


  if( word_class != PMT::FEM_HEADER) {
    
    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Encountered unexpected word while an event header search: %x (word type=%d)",
               word,word_class) );
    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;
    
  }

  if(status) {

    //
    // Check the last word type
    //
    switch(get_word_class(last_word)){
    case PMT::EVENT_HEADER:      
    case PMT::FEM_HEADER:
    case PMT::FEM_LAST_WORD:
      // Expected. Nothing to do
      break;
    case PMT::FEM_FIRST_WORD:
    case PMT::CHANNEL_HEADER:
    case PMT::CHANNEL_WORD:
    case PMT::UNDEFINED_WORD:
    case PMT::EVENT_LAST_WORD:
      // ERROR
      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Unexpected word while FEM_HEADER processing: %x (previous word=%x)",word,last_word));
      status = false;
      break;
    case PMT::CHANNEL_LAST_WORD:
      // Store data
      status = store_event();
      if(_debug_mode) {
    // We have to handle this case separately from a uniifed handling @ process_word
    // Because "this" header word is still good. Make a warning to a user.

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

    clear_event();

    status = true; 
      }
      break;
    }

    if(status){
    
      // Process the subject word as an event header
      if (_event_header_count<FEM_HEADER_COUNT) {
    
    // Store header words
    _event_header_words[_event_header_count]=word;
    _event_header_count++;
    
    // If stored number of header words reached to the expected number, decode.
    if(_event_header_count==FEM_HEADER_COUNT) {
      
      // Decode header words
      status = decode_fem_header(_event_header_words);
      
    }
      }else{
    
    // Raise error if a header word count > set constant (should not happen)
    Message::send(MSG::ERROR,__FUNCTION__,
              Form("Logic error: event header word counter not working! (%zu/%zu)",
               _event_header_count,FEM_HEADER_COUNT));
    status=false;
      }
    }
  }
  
  if(!status){
    
    Message::send(MSG::ERROR,__FUNCTION__,
          Form("Failed processing the word %x (last word %x) as an event header!",word,last_word));

  }
  
  last_word = word;
  return status;  
  
}

bool algo_tpc_xmit::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.

Implements algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 245 of file algo_tpc_xmit.cc.

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

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

  // This should not exist in TPC-XMIT
  Message::send(MSG::ERROR,__FUNCTION__,
        Form("FEM-LAST-WORD (%x, previous=%x) ... NOT expected for TPC!",word,last_word));

  last_word = word;

  return false;
}

bool algo_fem_decoder_base::process_word

(

const PMT::word_t

word

)

[virtual, inherited]

Implementation of algo_base::process_word.

Implements algo_base.

Reimplemented in algo_tpc_huffman.

Definition at line 36 of file algo_fem_decoder_base.cc.

References algo_base::_bt_mode, algo_base::_bt_nwords, algo_base::_bt_nwords_filled, algo_base::_bt_words, algo_base::_debug_mode, algo_fem_decoder_base::_header_info, algo_fem_decoder_base::_last_word, algo_fem_decoder_base::_search_for_next_event, decoder_base::_verbosity, algo_base::backtrace(), PMT::CHANNEL_HEADER, PMT::CHANNEL_LAST_WORD, PMT::CHANNEL_WORD, algo_fem_decoder_base::clear_event(), MSG::ERROR, PMT::EVENT_HEADER, algo_fem_decoder_base::InfoFEM_t::event_id, PMT::EVENT_LAST_WORD, PMT::FEM_FIRST_WORD, PMT::FEM_HEADER, PMT::FEM_LAST_WORD, algo_fem_decoder_base::get_word_class(), MSG::INFO, PMT::INVALID_WORD, algo_fem_decoder_base::process_ch_word(), algo_fem_decoder_base::process_event_header(), algo_fem_decoder_base::process_event_last_word(), algo_fem_decoder_base::process_fem_header(), algo_fem_decoder_base::process_fem_last_word(), Message::send(), PMT::UNDEFINED_WORD, and MSG::WARNING.

{
  //std::cout<<Form("%x",word)<<std::endl;
  // 
  // A simple function to call other members depending on the status.
  // Let other members to deal with expected/unexpected case
  //

  // 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);

  }

  bool status=true;
  PMT::word_t word_class=get_word_class(word);
  PMT::word_t last_word_class=get_word_class(_last_word);
  //
  // Skip this word if a boolean is set to skip to the next event header
  //
  if( _search_for_next_event &&  
      word_class == PMT::FEM_HEADER &&
      last_word_class != PMT::FEM_HEADER ) 
    
    _search_for_next_event = false;


  if( _search_for_next_event ) {

    if(_verbosity[MSG::INFO])

      Message::send(MSG::INFO,__FUNCTION__,
            Form("Skipping a word (%x, previous=%x) to the next event..",word,_last_word));

    _last_word = PMT::INVALID_WORD;

    return true;
  }

  switch(word_class){
    
  case PMT::EVENT_HEADER:

    // (1) Call process_event_header()
    status = process_event_header(word,_last_word);
    break;

  case PMT::FEM_HEADER:

    // (1) Check if the last word was EVENT_HEADER, FEM_HEADER, or EVENT_LAST_WORD
    //     - If EVENT_HEADER, continue to (2)
    //     - If FEM_HEADER,   continue to (2)
    //     - If EVENT_LAST_WORD, attempt to store & continue to (2)
    // (2) Call process_fem_header()
    status = process_fem_header(word,_last_word);
    break;

  case PMT::FEM_FIRST_WORD:
  case PMT::CHANNEL_HEADER:
  case PMT::CHANNEL_WORD:
  case PMT::CHANNEL_LAST_WORD:
  case PMT::FEM_LAST_WORD:
    {
      // (1) Call process_ch_word()
      //     - Children class should implement what should be checked in correlation to the last word.
      
      // Split two 16 bit words
      PMT::word_t first_word  = (word & 0xffff);
      PMT::word_t second_word = (word >> 16);

      if(status) status = process_ch_word(first_word,_last_word);
      
      // Check if the left 16-bit word is also the relevant type or not
      if(status){

    switch(get_word_class(second_word)){
    case PMT::FEM_FIRST_WORD:
    case PMT::CHANNEL_HEADER:
    case PMT::CHANNEL_WORD:
    case PMT::CHANNEL_LAST_WORD:
      status = process_ch_word(second_word,_last_word);
      break;
    case PMT::FEM_LAST_WORD:
      status = process_fem_last_word(second_word,_last_word);
      break;
    default:
      status = false;
      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Unexpected word (%x) while processing channel data (previous=%x)",second_word,first_word));
    }

      }
      break;
    }
  case PMT::EVENT_LAST_WORD:
    // (1) Call process_event_last_word()
    status = process_event_last_word(word,_last_word);
    break;

  case PMT::UNDEFINED_WORD: 


    if(word != 0x0 || (last_word_class != PMT::EVENT_LAST_WORD && last_word_class != PMT::FEM_LAST_WORD) ) {

      Message::send(MSG::ERROR,__FUNCTION__,
            Form("Undefined word: %x (previous = %x)",word,_last_word));
      
      status = false;
    }else if(_verbosity[MSG::INFO]){
    
      // This happens sometimes according to Chi 10/01/13
      Message::send(MSG::INFO,__FUNCTION__,
            Form("Padding of undefined word (tolerated): %x (previous=%x)",word,_last_word));
    }
    break;
  }

  if(!status){

    backtrace();

    if(_debug_mode) {

      if(_header_info.event_id>0)

    Message::send(MSG::WARNING,__FUNCTION__,Form("Failed decoding event %d ...",_header_info.event_id));

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

      _search_for_next_event = true;
      clear_event();
    }
  }

  return status;
}

void algo_tpc_xmit::reset

(

)

[protected, virtual]

Override function to reset the instance.

Reimplemented from algo_fem_decoder_base.

Reimplemented in algo_tpc_huffman.

Definition at line 17 of file algo_tpc_xmit.cc.

References _ch_data, _event_data, tpc_waveform::clear_data(), and algo_fem_decoder_base::reset().

Referenced by algo_tpc_xmit(), and algo_tpc_huffman::reset().

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

  _event_data = 0;

  _ch_data.clear_data();

  algo_fem_decoder_base::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]

A method to store event-wise data.

Implements algo_fem_decoder_base.

Definition at line 291 of file algo_tpc_xmit.cc.

References _event_data, algo_fem_decoder_base::_header_info, algo_base::_storage, decoder_base::_verbosity, check_event_quality(), 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 algo_tpc_huffman::process_ch_word(), process_event_header(), and algo_tpc_huffman::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(), algo_tpc_huffman::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(), algo_tpc_huffman::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(), algo_tpc_huffman::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(), algo_tpc_huffman::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(), 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]

Definition at line 108 of file algo_tpc_xmit.hh.

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

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

data checksum

Definition at line 126 of file algo_base.hh.

Referenced by 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(), process_ch_word(), algo_tpc_huffman::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(), algo_tpc_huffman::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]

Definition at line 110 of file algo_tpc_xmit.hh.

Referenced by clear_event(), process_ch_word(), algo_tpc_huffman::process_ch_word(), process_event_header(), algo_tpc_huffman::process_event_header(), algo_tpc_huffman::process_word(), reset(), and 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(), algo_tpc_huffman::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 algo_tpc_huffman::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 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(), algo_tpc_huffman::process_ch_word(), algo_tpc_huffman::process_event_last_word(), algo_tpc_huffman::process_word(), algo_fem_decoder_base::process_word(), 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 algo_tpc_huffman::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_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 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(), process_ch_word(), algo_tpc_huffman::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 algo_tpc_huffman::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 algo_tpc_huffman::process_word(), algo_fem_decoder_base::process_word(), and algo_fem_decoder_base::reset().

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(), process_event_header(), algo_tpc_huffman::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(), 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(), process_ch_word(), algo_tpc_huffman::process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), 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(), 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 algo_tpc_huffman::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_xmit.hh
• algo_tpc_xmit.cc

---