algo_pmt_xmit Class Reference
[Algorithm, Algorithm]

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

#include <algo_pmt_xmit.hh>

Inheritance diagram for algo_pmt_xmit:


Public Member Functions
	algo_pmt_xmit ()
	Default constructor.
virtual	~algo_pmt_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.
void	store_ch_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
pmt_waveform	_ch_data
pmt_wf_collection *	_event_data
PMT::DISCRIMINATOR	_last_disc_id
	Holder of last channel data's disc. id.
PMT::ch_number_t	_last_channel_number
	Holder of last channel data's channel number.
size_t	_channel_header_count
	A counter for channel header words.
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	CHANNEL_HEADER_COUNT = 3
	Number of channel header words.
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_pmt_xmit.hh.

Constructor & Destructor Documentation

algo_pmt_xmit::algo_pmt_xmit ( )

Default constructor.

Definition at line 7 of file algo_pmt_xmit.cc.

References reset().

00008   : algo_fem_decoder_base() 
00009 {
00010 //#########################################
00011 
00012   reset();
00013 
00014 }

virtual algo_pmt_xmit::~algo_pmt_xmit ( ) [inline, virtual]

Default destructor.

Definition at line 44 of file algo_pmt_xmit.hh.

00044 {};

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().

00397 {
00398 //#################################################
00399 
00400   bool status = true;
00401 
00402   switch(zero_count){
00403     
00404   case 0:
00405     wf.push_back( (*(wf.rbegin())) ); break;      
00406     
00407   case 1:
00408     wf.push_back( (*(wf.rbegin())) -1 ); break;
00409     
00410   case 2:
00411     wf.push_back( (*(wf.rbegin())) +1 ); break;
00412     
00413   case 3:
00414     wf.push_back( (*(wf.rbegin())) -2 ); break;
00415     
00416   case 4:
00417     wf.push_back( (*(wf.rbegin())) +2 ); break;
00418     
00419   case 5:
00420     wf.push_back( (*(wf.rbegin())) -3 ); break;
00421     
00422   case 6:
00423     wf.push_back( (*(wf.rbegin())) +3 ); break;
00424     
00425   default:
00426 
00427     std::cout<<zero_count<<std::endl;
00428     
00429     status = false;
00430   }
00431   
00432   return status;
00433 
00434 }

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().

00083   {
00084     Message::send(MSG::WARNING,__FUNCTION__,"Dumping a backtrace...");
00085     int ctr=1;
00086     for(std::deque<PMT::word_t>::const_iterator iter(_bt_words.begin());
00087     iter!=_bt_words.end();
00088     ++iter) {
00089       printf("%08x ",(*iter));
00090       if(ctr%8==0 && ctr) std::cout<<std::endl;
00091       ctr++;
00092     }
00093     std::cout<<std::endl<<std::endl;
00094   };

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.

00071 {return _bt_nwords;};

bool algo_pmt_xmit::check_event_quality ( ) [protected, virtual]

Implementation of algo_base::check_event_quality.

Reimplemented from algo_fem_decoder_base.

Definition at line 74 of file algo_pmt_xmit.cc.

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

Referenced by store_event().

00074                                        {
00075 //#########################################################
00076 
00077   bool status = true;
00078 
00079   // Check if _checksum and _nwords agrees with that of event header.
00080   _nwords-=1;
00081   if(_nwords!=_header_info.nwords){
00082 
00083     Message::send(MSG::ERROR,__FUNCTION__,
00084           Form("Disagreement on nwords: counted=%u, expected=%u",_nwords,_header_info.nwords));
00085 
00086     status = false;
00087 
00088   }
00089 
00090   // checksum is only 24 bit!
00091   _checksum = (_checksum & 0xffffff);
00092   if(_checksum!=_header_info.checksum){
00093 
00094     Message::send(MSG::ERROR,__FUNCTION__,
00095           Form("Disagreement on checksum: summed=%x, expected=%x",_checksum,_header_info.checksum));
00096 
00097     status = false;
00098 
00099   }
00100 
00101   return status;
00102 
00103 }

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.

00046 {return _name;};

void algo_pmt_xmit::clear_event ( ) [protected, virtual]

A method to clear event-wise data.

Reimplemented from algo_fem_decoder_base.

Definition at line 30 of file algo_pmt_xmit.cc.

References _ch_data, _channel_header_count, _event_data, _last_channel_number, _last_disc_id, pmt_waveform::clear_data(), pmt_wf_collection::clear_data(), algo_fem_decoder_base::clear_event(), PMT::DISC_MAX, and PMT::INVALID_CH.

Referenced by reset(), and store_event().

00030                                 {
00031 //#########################################
00032 
00033   algo_fem_decoder_base::clear_event();
00034 
00035   if(_event_data)
00036 
00037     _event_data->clear_data();
00038   
00039   _ch_data.clear_data();
00040   
00041   _channel_header_count = 0;
00042 
00043   _last_channel_number=PMT::INVALID_CH;
00044   _last_disc_id=PMT::DISC_MAX;
00045 
00046 }

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

Definition at line 233 of file algo_pmt_xmit.cc.

References decoder_base::_buf, _ch_data, _channel_header_count, _event_data, _last_channel_number, _last_disc_id, decoder_base::_verbosity, pmt_waveform::channel_frame_id(), PMT::CHANNEL_HEADER, CHANNEL_HEADER_COUNT, PMT::CHANNEL_LAST_WORD, pmt_waveform::channel_number(), PMT::CHANNEL_WORD, pmt_waveform::clear_data(), MSG::DEBUG, pmt_waveform::disc_id(), MSG::ERROR, pmt_wf_collection::event_frame_id(), PMT::EVENT_HEADER, pmt_wf_collection::event_id(), PMT::EVENT_LAST_WORD, PMT::FEM_FIRST_WORD, PMT::FEM_HEADER, PMT::FEM_LAST_WORD, get_word_class(), MSG::INFO, MSG::NORMAL, algo_fem_decoder_base::round_diff(), Message::send(), pmt_waveform::set_channel_frame_id(), pmt_waveform::set_channel_number(), pmt_waveform::set_disc_id(), pmt_waveform::set_timeslice(), store_ch_data(), pmt_waveform::timeslice(), and PMT::UNDEFINED_WORD.

Referenced by process_ch_word().

00235 {
00236 //#########################################################
00237 
00238   PMT::PMT_WORD word_class      = get_word_class(word);
00239   PMT::PMT_WORD last_word_class = get_word_class(last_word);
00240   bool status=true;
00241 
00242   if(_verbosity[MSG::DEBUG]){
00243     sprintf(_buf,"Decoding word: %x ... last word class: %d",word,last_word_class);
00244     Message::send(MSG::DEBUG,__FUNCTION__,_buf);
00245   }  
00246   
00247   switch(word_class){
00248 
00249   case PMT::EVENT_HEADER:
00250   case PMT::FEM_HEADER:
00251   case PMT::UNDEFINED_WORD:
00252   case PMT::FEM_LAST_WORD:
00253   case PMT::EVENT_LAST_WORD:
00254     Message::send(MSG::ERROR,__FUNCTION__,
00255           Form("Unexpected word: %x (previous=%x)",word,last_word));
00256     status = false;
00257     break;
00258   case PMT::FEM_FIRST_WORD:
00259     //
00260     // First channel word in this event ... nothing special to do
00261     if(last_word_class!=PMT::FEM_HEADER){
00262       Message::send(MSG::ERROR,__FUNCTION__,
00263             Form("Found FEM first word (%x) in an unexpected place (previous=%x)!",word,last_word));
00264       status=false;
00265     }
00266     break;
00267 
00268   case PMT::CHANNEL_HEADER:
00269     //
00270     // Channel header ... read in channel info from this word
00271     if(last_word_class!=PMT::FEM_FIRST_WORD && 
00272        last_word_class!=PMT::CHANNEL_LAST_WORD) {
00273       Message::send(MSG::ERROR,__FUNCTION__,
00274             Form("Found channel header (%x) in an unexpected place (previous=%x)!",word,last_word));
00275       status=false;
00276     }else{
00277       // Initialize channel info, then fill with channel number & disc. id.
00278       _channel_header_count=0;
00279       _ch_data.clear_data();
00280       _channel_header_count=1;
00281       // Channel Number
00282       _ch_data.set_channel_number( word & 0x3f ); 
00283       // Discriminator ID
00284       _ch_data.set_disc_id((PMT::DISCRIMINATOR)((word & 0xfff)>>9));  
00285     }
00286     break;
00287 
00288   case PMT::CHANNEL_WORD:
00289   case PMT::CHANNEL_LAST_WORD:
00290     //
00291     // This is channel ADC count or possibly remaining channel header info
00292     // The first two sample are treated as channel header info
00293     if(last_word_class!=PMT::CHANNEL_HEADER && 
00294        last_word_class!=PMT::CHANNEL_WORD &&
00295        last_word_class!=PMT::CHANNEL_LAST_WORD ) {
00296       // Sanity check: the last word should be either channel header or data word.
00297       Message::send(MSG::ERROR,__FUNCTION__,
00298             Form("Found channel word (%x) in an unexpected place (previous=%x)!",word,last_word));
00299 
00300       status=false;
00301     }else{
00302       // Treat a case of missing very first channel header word: happens when there is no time in between two readout data.
00303       if(last_word_class==PMT::CHANNEL_LAST_WORD){
00304     // In this case, we should be missing the CHANNEL_HEADER because this pulse is from the same channel & discriminator id.
00305     // Do an operation that is done for the case of CHANNEL_HEADER, but use a stored value of channel number & disc. id.
00306     _channel_header_count=1;
00307     _ch_data.set_channel_number(_last_channel_number);
00308     _ch_data.set_disc_id(_last_disc_id);
00309     if(_verbosity[MSG::NORMAL])
00310       Message::send(MSG::NORMAL,__FUNCTION__,
00311             Form("Found consecutively readout data arrays @ event %d (missing channel very first header)!",
00312                  _event_data->event_id())
00313             );
00314       }
00315 
00316       //
00317       // Ordinary operation for channel header / adc words
00318       //
00319       if(_channel_header_count==CHANNEL_HEADER_COUNT ) {
00320 
00321     // Finished reading in header words. This should be a mere ADC count.
00322     // Raise error if the last word class is not channel word
00323     if(last_word_class!=PMT::CHANNEL_WORD){
00324 
00325       Message::send(MSG::ERROR,__FUNCTION__,
00326             Form("Found channel word (%x) in an unexpected place (previous=%x)!",word,last_word));
00327 
00328       status = false;
00329     }     
00330     else if(word_class!=PMT::CHANNEL_LAST_WORD)
00331 
00332       _ch_data.push_back(word & 0xfff); 
00333     
00334       }else if(last_word_class==PMT::CHANNEL_HEADER   ) {
00335     // First of 2 channel header words. Record the values.
00336 
00337     // This gives upper 8 bits of 20-bit timeslice number
00338     _ch_data.set_timeslice( (word & 0x1f)<<12 );       
00339 
00340     // Lower 3 of 8 bits is the channel frame ID
00341     _ch_data.set_channel_frame_id( ((word & 0xff)>>5) +
00342                        (((_event_data->event_frame_id())>>3)<<3) ); 
00343 
00344     // Correct channel frame id roll-over w.r.t. event frame id
00345     _ch_data.set_channel_frame_id(round_diff(_event_data->event_frame_id(),
00346                          _ch_data.channel_frame_id(),
00347                          0x7));
00348     _channel_header_count++;
00349       }else if(last_word_class==PMT::CHANNEL_WORD     ) {
00350     // Second of 2 channel header words. Record the values & inspect them.
00351     _ch_data.set_timeslice(_ch_data.timeslice() + (word & 0xfff)); // This gives lower 12 bits of 20-bit timeslice number
00352     _channel_header_count++;
00353 
00354     if(_verbosity[MSG::INFO]){
00355       sprintf(_buf,"Read-in headers for Ch. %-3d!",_ch_data.channel_number());
00356       Message::send(MSG::INFO,_buf);
00357     }
00358       }
00359 
00360       // If this is channel's last word, store & clear channel info
00361       if(word_class==PMT::CHANNEL_LAST_WORD){
00362     if(_verbosity[MSG::INFO]){
00363       sprintf(_buf,"Encountered the last word (%x) for channel %d",word,_ch_data.channel_number());
00364       Message::send(MSG::INFO,_buf);
00365       sprintf(_buf,"Event frame  : %d",_event_data->event_frame_id());
00366       Message::send(MSG::INFO,_buf);
00367       sprintf(_buf,"PMT frame    : %d",_ch_data.channel_frame_id());
00368       Message::send(MSG::INFO,_buf);
00369       sprintf(_buf,"Disc. ID     : %d",_ch_data.disc_id());
00370       Message::send(MSG::INFO,_buf);
00371       sprintf(_buf,"Start Time   : %d",_ch_data.timeslice());
00372       Message::send(MSG::INFO,_buf);
00373       sprintf(_buf,"# ADC sample : %zd",_ch_data.size());
00374       Message::send(MSG::INFO,_buf);
00375     }
00376     store_ch_data();
00377       }
00378     }
00379     break;
00380   }
00381 
00382   return status;
00383 
00384 }

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.

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

00295                                                                           {
00296 //#################################################
00297 
00298   bool status=true;
00299   //
00300   // Get event information
00301   //
00302 
00303   // (1) check if the very first 16-bit word is as expected
00304   if(!( event_header[0] & 0xffff))
00305     Message::send(MSG::ERROR,"Unexpected first word in event headers!");
00306 
00307   if(!status) return status;
00308 
00309   // Initialize data holder
00310   _header_info.clear_event();
00311 
00312   // (2) get module address ... lowest 5 of 12 bits
00313   _header_info.module_address = ( (event_header[0]>>16 & 0xfff)    & 0x1f);
00314 
00315   // (3) get module ID number ... upper 7 bit of 12 bits
00316   _header_info.module_id      = ( (event_header[0]>>16 & 0xfff)>>5 & 0x7f);
00317 
00318   // (4) get number of 16-bit words to be read in this event.
00319   // Lower 12 bits of two 16-bit words.
00320   // The very last "last word for channel info" is not included in this.
00321   // For later checking purpose, increment by 1.
00322   _header_info.nwords         = ( (((event_header[1]>>16) & 0xfff) + ((event_header[1] & 0xfff)<<12)));
00323 
00324   // (5) get event ID
00325   // Lower 12 bits of two 16-bit words.
00326   _header_info.event_id       = ( (((event_header[2]>>16) & 0xfff) + ((event_header[2] & 0xfff)<<12)));
00327 
00328   // (6) get frame ID
00329   // Lower 12 bits of two 16-bit words.
00330   _header_info.event_frame_id = ( (((event_header[3]>>16) & 0xfff) + ((event_header[3] & 0xfff)<<12)));
00331 
00332   // (7) get checksum
00333   _header_info.checksum       = ( (((event_header[4]>>16) & 0xfff) + ((event_header[4] & 0xfff)<<12)));
00334 
00335 
00336 #ifdef INCLUDE_EXTRA_HEADER
00337   _header_info.trigger_frame_id  = ( ((event_header[5] & 0xfff)>>4 & 0xf) +
00338                      (((_header_info.event_frame_id)>>4)<<4)); 
00339 
00340   // Correct for a roll over
00341   _header_info.trigger_frame_id  = round_diff(_header_info.event_frame_id, _header_info.trigger_frame_id, 0x7);
00342 
00343   _header_info.trigger_timeslice = ((((event_header[5]>>16) & 0xf)<<8) + (event_header[5] & 0xff));
00344 
00345 #endif
00346 
00347   // Report if verbosity is set.
00348   if(_verbosity[MSG::INFO])
00349     {
00350       Message::send(MSG::INFO,Form("Module %d (ID=%d)", _header_info.module_address, _header_info.module_id));
00351       Message::send(MSG::INFO,Form("Event ID %d",_header_info.event_id));
00352       Message::send(MSG::INFO,Form("Frame ID %d",_header_info.event_frame_id));
00353       Message::send(MSG::INFO,Form("Number of Words = %d",_header_info.nwords));
00354       Message::send(MSG::INFO,Form("Checksum = %x", _header_info.checksum));
00355       Message::send(MSG::INFO,Form("Trigger Frame %d",_header_info.trigger_frame_id));
00356       Message::send(MSG::INFO,Form("Trigger Sample %d",_header_info.trigger_timeslice));
00357     }
00358 
00359   _checksum=0;
00360 
00361   _nwords=0;
00362               
00363   return status;
00364 }

virtual void algo_base::finalize ( ) [inline, virtual, inherited]

Function called just after processing word.

Definition at line 52 of file algo_base.hh.

00052 {};

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.

00043 {return _verbosity_level;};

virtual PMT::PMT_WORD algo_pmt_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.

Definition at line 47 of file algo_pmt_xmit.hh.

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

Referenced by decode_ch_word(), process_event_header(), process_event_last_word(), and process_fem_last_word().

00047                                                                         {
00048     // One of core functions to identify PMT binary word format
00049     if( (word & 0xffffffff) == 0xffffffff )
00050       return PMT::EVENT_HEADER;
00051     if( (word & 0xffff) == 0xffff )
00052       return PMT::FEM_HEADER;
00053     else if( (word & 0xf000) == 0xf000 )
00054       return PMT::FEM_HEADER;
00055     else if( (word & 0xf000) == 0x4000 )
00056       return PMT::FEM_FIRST_WORD;
00057     else if( (word & 0xf000) == 0x9000 )
00058       return PMT::CHANNEL_HEADER;
00059     else if( (word & 0xf000) == 0xa000 )
00060       return PMT::CHANNEL_WORD;
00061     else if( (word & 0xf000) == 0xb000 )
00062       return PMT::CHANNEL_LAST_WORD;
00063     else if( (word & 0xf000) == 0xc000 )
00064       return PMT::FEM_LAST_WORD;
00065     else if( (word & 0xf0000000) == 0xe0000000 )
00066       return PMT::EVENT_LAST_WORD;
00067     else if( (word & 0xf000) == 0xe000 )
00068       return PMT::EVENT_LAST_WORD;
00069     else
00070       return PMT::UNDEFINED_WORD;
00071   };

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().

00007 {
00008   _checksum=0x0;
00009   _nwords=0;
00010 }

virtual bool algo_pmt_xmit::is_compressed ( const PMT::word_t word ) [inline, protected, virtual]

Definition at line 88 of file algo_pmt_xmit.hh.

00088 { 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.

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

bool algo_pmt_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.

Definition at line 49 of file algo_pmt_xmit.cc.

References decoder_base::_buf, algo_base::_checksum, algo_base::_nwords, decoder_base::_verbosity, MSG::DEBUG, decode_ch_word(), and Message::send().

00051 {
00052 //#########################################
00053 
00054   bool status=true;
00055 
00056   if(_verbosity[MSG::DEBUG]){
00057     sprintf(_buf,"Processing ch-word: %x",word);
00058     Message::send(MSG::DEBUG,__FUNCTION__,_buf);
00059   }
00060 
00061   status = decode_ch_word(word,last_word);
00062 
00063   if(status){
00064     _nwords++;
00065     _checksum+=word;
00066   }
00067 
00068   last_word = word;
00069 
00070   return status;
00071 }

bool algo_pmt_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.

Definition at line 108 of file algo_pmt_xmit.cc.

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

00110 {
00111 //#################################################
00112 
00113   bool status = true;
00114 
00115   if(!_event_data)
00116 
00117     _event_data = (pmt_wf_collection*)(_storage->get_data(DATA_STRUCT::PMT_WF_COLLECTION));
00118   
00119   else if(get_word_class(last_word) != PMT::EVENT_LAST_WORD){
00120 
00121     Message::send(MSG::ERROR,__FUNCTION__,
00122           Form("Unexpected word (%x, previous=%x) while processing event header!",word,last_word));
00123 
00124     status = false;
00125 
00126   }
00127 
00128   last_word = word;
00129 
00130   return status;
00131 
00132 }

bool algo_pmt_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.

Definition at line 168 of file algo_pmt_xmit.cc.

References decoder_base::_verbosity, MSG::ERROR, PMT::FEM_LAST_WORD, get_word_class(), MSG::INFO, and Message::send().

00170 {  
00171 //#########################################################
00172 
00173   bool status = true;
00174 
00175   if(_verbosity[MSG::INFO])
00176     
00177     Message::send(MSG::INFO,__FUNCTION__,Form("End of event word: %x...",word));
00178 
00179   if(get_word_class(last_word)!=PMT::FEM_LAST_WORD){
00180 
00181     Message::send(MSG::ERROR,__FUNCTION__,
00182           Form("Unexpected word: %x (previous = %x)",word,last_word));
00183 
00184     status = false;
00185 
00186   }
00187 
00188   last_word = word;
00189 
00190   return status;
00191 }

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().

00185                                                                                          {
00186 //#################################################
00187   
00188   bool status=true;
00189   //
00190   // Check if this is an event header word or not
00191   //
00192   PMT::PMT_WORD word_class=get_word_class(word);
00193   if(_verbosity[MSG::DEBUG]){
00194     sprintf(_buf,"Processing Header: %x",word);
00195     Message::send(MSG::DEBUG,__FUNCTION__,_buf);
00196   }
00197 
00198 
00199   if( word_class != PMT::FEM_HEADER) {
00200     
00201     Message::send(MSG::ERROR,__FUNCTION__,
00202           Form("Encountered unexpected word while an event header search: %x (word type=%d)",
00203                word,word_class) );
00204     status = false;    
00205 
00206   }else if(get_word_class(word>>16)!=PMT::FEM_HEADER) {
00207 
00208     // Event header should come as a 32-bit word which is a pair of two 16-bit header words.
00209     // The first 16-bit is already checked by this point. Check the second part.
00210 
00211     Message::send(MSG::ERROR,__FUNCTION__,Form("Found an odd event header word: %x",word));
00212       
00213     status = false;
00214     
00215   }
00216 
00217   if(status) {
00218 
00219     //
00220     // Check the last word type
00221     //
00222     switch(get_word_class(last_word)){
00223     case PMT::EVENT_HEADER:      
00224     case PMT::FEM_HEADER:
00225     case PMT::FEM_LAST_WORD:
00226       // Expected. Nothing to do
00227       break;
00228     case PMT::FEM_FIRST_WORD:
00229     case PMT::CHANNEL_HEADER:
00230     case PMT::CHANNEL_WORD:
00231     case PMT::UNDEFINED_WORD:
00232     case PMT::EVENT_LAST_WORD:
00233       // ERROR
00234       Message::send(MSG::ERROR,__FUNCTION__,
00235             Form("Unexpected word while FEM_HEADER processing: %x (previous word=%x)",word,last_word));
00236       status = false;
00237       break;
00238     case PMT::CHANNEL_LAST_WORD:
00239       // Store data
00240       status = store_event();
00241       if(_debug_mode) {
00242     // We have to handle this case separately from a uniifed handling @ process_word
00243     // Because "this" header word is still good. Make a warning to a user.
00244 
00245     Message::send(MSG::WARNING,__FUNCTION__,"DEBUG MODE => Continue to the next event...\n");
00246 
00247     clear_event();
00248 
00249     status = true; 
00250       }
00251       break;
00252     }
00253 
00254     if(status){
00255     
00256       // Process the subject word as an event header
00257       if (_event_header_count<FEM_HEADER_COUNT) {
00258     
00259     // Store header words
00260     _event_header_words[_event_header_count]=word;
00261     _event_header_count++;
00262     
00263     // If stored number of header words reached to the expected number, decode.
00264     if(_event_header_count==FEM_HEADER_COUNT) {
00265       
00266       // Decode header words
00267       status = decode_fem_header(_event_header_words);
00268       
00269     }
00270       }else{
00271     
00272     // Raise error if a header word count > set constant (should not happen)
00273     Message::send(MSG::ERROR,__FUNCTION__,
00274               Form("Logic error: event header word counter not working! (%zu/%zu)",
00275                _event_header_count,FEM_HEADER_COUNT));
00276     status=false;
00277       }
00278     }
00279   }
00280   
00281   if(!status){
00282     
00283     Message::send(MSG::ERROR,__FUNCTION__,
00284           Form("Failed processing the word %x (last word %x) as an event header!",word,last_word));
00285 
00286   }
00287   
00288   last_word = word;
00289   return status;  
00290   
00291 }

bool algo_pmt_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.

Definition at line 135 of file algo_pmt_xmit.cc.

References algo_base::_nwords, decoder_base::_verbosity, PMT::CHANNEL_LAST_WORD, MSG::ERROR, PMT::FEM_FIRST_WORD, get_word_class(), MSG::INFO, Message::send(), and store_event().

00137 {
00138 //#########################################################
00139 
00140   bool status = true;
00141 
00142   if(_verbosity[MSG::INFO])
00143       
00144     Message::send(MSG::INFO,__FUNCTION__,Form("End of FEM word: %x...",word));
00145   
00146   PMT::word_t last_word_class = get_word_class(last_word);
00147   if(last_word_class != PMT::CHANNEL_LAST_WORD &&
00148      last_word_class != PMT::FEM_FIRST_WORD) {
00149 
00150     Message::send(MSG::ERROR,__FUNCTION__,
00151           Form("Unexpected word: %x (previous = %x)",word,last_word));
00152 
00153     status = false;
00154 
00155   }
00156 
00157   _nwords++;
00158   //_checksum+=word;
00159 
00160   if(status) status=store_event();
00161 
00162   last_word = word;
00163 
00164   return status;
00165 }

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.

00038 {
00039   //std::cout<<Form("%x",word)<<std::endl;
00040   // 
00041   // A simple function to call other members depending on the status.
00042   // Let other members to deal with expected/unexpected case
00043   //
00044 
00045   // If in back_trace mode, add this word in record
00046   if(_bt_mode){
00047     
00048     // Check if buffer is filled
00049     if(!_bt_nwords_filled)
00050       _bt_nwords_filled = (_bt_nwords == _bt_words.size());
00051 
00052     // If filled, remove the oldest element
00053     if(_bt_nwords_filled)
00054       _bt_words.pop_front();
00055 
00056     // Add new word
00057     _bt_words.push_back(word);
00058 
00059   }
00060 
00061   bool status=true;
00062   PMT::word_t word_class=get_word_class(word);
00063   PMT::word_t last_word_class=get_word_class(_last_word);
00064   //
00065   // Skip this word if a boolean is set to skip to the next event header
00066   //
00067   if( _search_for_next_event &&  
00068       word_class == PMT::FEM_HEADER &&
00069       last_word_class != PMT::FEM_HEADER ) 
00070     
00071     _search_for_next_event = false;
00072 
00073 
00074   if( _search_for_next_event ) {
00075 
00076     if(_verbosity[MSG::INFO])
00077 
00078       Message::send(MSG::INFO,__FUNCTION__,
00079             Form("Skipping a word (%x, previous=%x) to the next event..",word,_last_word));
00080 
00081     _last_word = PMT::INVALID_WORD;
00082 
00083     return true;
00084   }
00085 
00086   switch(word_class){
00087     
00088   case PMT::EVENT_HEADER:
00089 
00090     // (1) Call process_event_header()
00091     status = process_event_header(word,_last_word);
00092     break;
00093 
00094   case PMT::FEM_HEADER:
00095 
00096     // (1) Check if the last word was EVENT_HEADER, FEM_HEADER, or EVENT_LAST_WORD
00097     //     - If EVENT_HEADER, continue to (2)
00098     //     - If FEM_HEADER,   continue to (2)
00099     //     - If EVENT_LAST_WORD, attempt to store & continue to (2)
00100     // (2) Call process_fem_header()
00101     status = process_fem_header(word,_last_word);
00102     break;
00103 
00104   case PMT::FEM_FIRST_WORD:
00105   case PMT::CHANNEL_HEADER:
00106   case PMT::CHANNEL_WORD:
00107   case PMT::CHANNEL_LAST_WORD:
00108   case PMT::FEM_LAST_WORD:
00109     {
00110       // (1) Call process_ch_word()
00111       //     - Children class should implement what should be checked in correlation to the last word.
00112       
00113       // Split two 16 bit words
00114       PMT::word_t first_word  = (word & 0xffff);
00115       PMT::word_t second_word = (word >> 16);
00116 
00117       if(status) status = process_ch_word(first_word,_last_word);
00118       
00119       // Check if the left 16-bit word is also the relevant type or not
00120       if(status){
00121 
00122     switch(get_word_class(second_word)){
00123     case PMT::FEM_FIRST_WORD:
00124     case PMT::CHANNEL_HEADER:
00125     case PMT::CHANNEL_WORD:
00126     case PMT::CHANNEL_LAST_WORD:
00127       status = process_ch_word(second_word,_last_word);
00128       break;
00129     case PMT::FEM_LAST_WORD:
00130       status = process_fem_last_word(second_word,_last_word);
00131       break;
00132     default:
00133       status = false;
00134       Message::send(MSG::ERROR,__FUNCTION__,
00135             Form("Unexpected word (%x) while processing channel data (previous=%x)",second_word,first_word));
00136     }
00137 
00138       }
00139       break;
00140     }
00141   case PMT::EVENT_LAST_WORD:
00142     // (1) Call process_event_last_word()
00143     status = process_event_last_word(word,_last_word);
00144     break;
00145 
00146   case PMT::UNDEFINED_WORD: 
00147 
00148 
00149     if(word != 0x0 || (last_word_class != PMT::EVENT_LAST_WORD && last_word_class != PMT::FEM_LAST_WORD) ) {
00150 
00151       Message::send(MSG::ERROR,__FUNCTION__,
00152             Form("Undefined word: %x (previous = %x)",word,_last_word));
00153       
00154       status = false;
00155     }else if(_verbosity[MSG::INFO]){
00156     
00157       // This happens sometimes according to Chi 10/01/13
00158       Message::send(MSG::INFO,__FUNCTION__,
00159             Form("Padding of undefined word (tolerated): %x (previous=%x)",word,_last_word));
00160     }
00161     break;
00162   }
00163 
00164   if(!status){
00165 
00166     backtrace();
00167 
00168     if(_debug_mode) {
00169 
00170       if(_header_info.event_id>0)
00171 
00172     Message::send(MSG::WARNING,__FUNCTION__,Form("Failed decoding event %d ...",_header_info.event_id));
00173 
00174       Message::send(MSG::WARNING,__FUNCTION__,"DEBUG MODE => Continue to the next event...\n");
00175 
00176       _search_for_next_event = true;
00177       clear_event();
00178     }
00179   }
00180 
00181   return status;
00182 }

void algo_pmt_xmit::reset ( ) [protected, virtual]

Override function to reset the instance.

Reimplemented from algo_fem_decoder_base.

Definition at line 17 of file algo_pmt_xmit.cc.

References _event_data, clear_event(), and algo_fem_decoder_base::reset().

Referenced by algo_pmt_xmit().

00017                           {
00018 //#########################################
00019 
00020   _event_data = 0;
00021 
00022   clear_event();
00023 
00024   algo_fem_decoder_base::reset();
00025 
00026 }

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 decode_ch_word(), and algo_fem_decoder_base::decode_fem_header().

00372 {
00373   // Used to recover pmt/trigger frame id from roll over effect.
00374   // One can test this by simply calling this function.
00375   // For instance, to test the behavior for a roll-over of 0x7 ...
00376   //
00377   // > root
00378   // root[0] gSystem->Load("libDecoder")
00379   // root[1] algo_slow_readout_decoder k
00380   // root [6] k.get_pmt_frame(583,584,0x7)
00381   // (const unsigned int)584
00382   // root [7] k.get_pmt_frame(584,583,0x7)
00383   // (const unsigned int)583
00384   //
00385   // I think this implementation works. ... Aug. 12 2013
00386   if( (subject_id > ref_id) && ((subject_id-ref_id) >= diff) )
00387     return subject_id - (diff+1);
00388   else if( (ref_id > subject_id) && ((ref_id-subject_id) >= diff) )    
00389     return subject_id + (diff+1);
00390   else
00391     return subject_id;
00392 
00393 }

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().

00065                                                   {
00066     _bt_nwords=nwords;
00067     _bt_mode=(bool)(nwords);
00068   };

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().

00059 {_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().

00062 {_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().

00011                                               {
00012 
00013   _verbosity_level=level;
00014 
00015   for(size_t i=(size_t)(MSG::DEBUG); i<(size_t)(MSG::MSG_TYPE_MAX); ++i)
00016     _verbosity[i]=false;
00017 
00018   switch(level){
00019   case MSG::DEBUG:
00020     _verbosity[MSG::DEBUG]=true;
00021   case MSG::INFO:
00022     _verbosity[MSG::INFO]=true;
00023   case MSG::NORMAL:
00024     _verbosity[MSG::NORMAL]=true;
00025   case MSG::WARNING:
00026     _verbosity[MSG::WARNING]=true;
00027   case MSG::ERROR:
00028     _verbosity[MSG::ERROR]=true;
00029   case MSG::MSG_TYPE_MAX:
00030     break;
00031   }
00032 
00033 }

void algo_pmt_xmit::store_ch_data ( ) [protected]

Definition at line 386 of file algo_pmt_xmit.cc.

References _ch_data, _channel_header_count, _event_data, _last_channel_number, _last_disc_id, pmt_waveform::channel_number(), pmt_waveform::clear_data(), and pmt_waveform::disc_id().

Referenced by decode_ch_word().

00386                                  {
00387 
00388   _event_data->push_back(_ch_data);
00389   
00390   // Store this waveform's channel number and discriminator id.
00391   // This may be used in the next pulse in case the next pulse is coming with no time space in between.
00392   // In such case, the next pulse is missing the channel very first header word because it is supposed
00393   // to be combined.
00394   _last_channel_number=_ch_data.channel_number();
00395   _last_disc_id=_ch_data.disc_id();
00396 
00397   _channel_header_count=0;
00398   _ch_data.clear_data();
00399 
00400 }

bool algo_pmt_xmit::store_event ( ) [protected, virtual]

A method to store event-wise data.

Implements algo_fem_decoder_base.

Definition at line 194 of file algo_pmt_xmit.cc.

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

Referenced by process_fem_last_word().

00194                                {
00195 //#########################################################
00196 
00197   bool status = check_event_quality();
00198 
00199   // Store if condition is satisfied
00200   if(status) {
00201 
00202     if(_verbosity[MSG::INFO]){
00203 
00204       Message::send(MSG::INFO,__FUNCTION__,
00205             Form("Storing event %u with %zu channel entries...",
00206              _event_data->event_id(), _event_data->size()));
00207 
00208     }
00209 
00210     _event_data->set_module_address    ( _header_info.module_address    );
00211     _event_data->set_module_id         ( _header_info.module_id         );
00212     _event_data->set_event_id          ( _header_info.event_id          );
00213     _event_data->set_event_frame_id    ( _header_info.event_frame_id    );
00214     _event_data->set_trigger_frame_id  ( _header_info.trigger_frame_id  );
00215     _event_data->set_trigger_timeslice ( _header_info.trigger_timeslice );
00216     _event_data->set_nwords            ( _header_info.nwords            );
00217     _event_data->set_checksum          ( _header_info.checksum          );
00218 
00219     status = _storage->next_event();
00220 
00221   }
00222   else
00223     
00224     Message::send(MSG::ERROR,__FUNCTION__,
00225           Form("Skipping to store event %d...",_header_info.event_id));
00226 
00227   clear_event();
00228 
00229   return status;
00230 }