bin_io_handler Class Reference
[FileIO, FileIO]

Operates on bin/ASCII file and read-out 32-bit words consecutively. More...

#include <bin_io_handler.hh>

Inheritance diagram for bin_io_handler:

decoder_base List of all members.

Public Types

 READ
 READ mode.
 WRITE
 WRITE mode.
 INIT
 Status initialized, before opening a file.
 OPENED
 File opened, before start operation.
 OPERATING
 Operating I/O, before closing file.
 CLOSED
 Final status: closed a file.
enum  MODE { READ, WRITE }
 I/O mode enum. More...
enum  STATUS { INIT, OPENED, OPERATING, CLOSED }
 Process status enum. More...

Public Member Functions

 bin_io_handler (FORMAT::INPUT_FILE type=FORMAT::UNDEFINED)
 Default constructor.
 ~bin_io_handler ()
 Default destructor.
bool write_word (const PMT::word_t word)
 Send a word to this method to write out in WRITE mode.
bool write_multi_word (const PMT::word_t *words, const size_t entries)
 Send an array of words to this method to write out in WRITE mode.
PMT::word_t read_word ()
 Receive 32-bit word from this method in READ mode.
void set_format (FORMAT::INPUT_FILE f)
 Setter for the input file format defined in FORMAT::INPUT_FILE.
void set_mode (MODE mode)
 Setter for I/O mode defined in bin_io_handler::MODE.
void set_filename (std::string name)
 Setter for input/output file name.
bool eof () const
 A method to return if eof is reached or not.
bool open ()
 A method to open input/output file.
bool is_open () const
 A method to check if a file is still in open state.
void close ()
 A method to close input/output file.
void reset ()
 A method to initialize the class instance.
PMT::word_t read_multi_word (size_t length=0)
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 Attributes

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

Private Attributes

std::string _filename
 Input/Output filename.
bool _eof
 EOF boolean.
UShort_t _nwords_in_file
 Number of words read or written per file.
UInt_t _checksum
 checksum of operated 32-bit words
size_t _file_suffix
 A counter for file suffix in case output is too big.
PMT::word_t _single_word [1]
 A place holder variable to process a single word.
PMT::word_t _word
 A word set to be read/write-out.
PMT::word_t _nchars
 Number of chars read in case of ASCII file.
FORMAT::INPUT_FILE _format
 Input file format.
STATUS _status
 Process status flag.
MODE _mode
 I/O mode.
FILE * _handler
 File handler pointer.
std::vector< PMT::word_t > _read_word_buffer
size_t _multi_word_index

Detailed Description

Operates on bin/ASCII file and read-out 32-bit words consecutively.

Definition at line 26 of file bin_io_handler.hh.

Member Enumeration Documentation

enum bin_io_handler::MODE

I/O mode enum.

Enumerator:
READ  READ mode.
WRITE  WRITE mode.

Definition at line 31 of file bin_io_handler.hh.

00031            {
00032     READ, 
00033     WRITE 
00034   };

enum bin_io_handler::STATUS

Process status enum.

Enumerator:
INIT  Status initialized, before opening a file.
OPENED  File opened, before start operation.
OPERATING  Operating I/O, before closing file.
CLOSED  Final status: closed a file.

Definition at line 37 of file bin_io_handler.hh.

00037              {
00038     INIT,      
00039     OPENED,    
00040     OPERATING, 
00041     CLOSED     
00042   };

Constructor & Destructor Documentation

bin_io_handler::bin_io_handler ( FORMAT::INPUT_FILE  type = FORMAT::UNDEFINED  ) 

Default constructor.

Definition at line 6 of file bin_io_handler.cc.

References decoder_base::_name, _status, INIT, and reset().

00007   : decoder_base(),  _format(type)
00008 {
00009   _name="bin_io_handler";
00010   _status=INIT;
00011   reset();
00012 }

bin_io_handler::~bin_io_handler (  )  [inline]

Default destructor.

Definition at line 48 of file bin_io_handler.hh.

00048 {};

Member Function Documentation

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 bin_io_handler::close (  ) 

A method to close input/output file.

Definition at line 94 of file bin_io_handler.cc.

References decoder_base::_buf, _filename, _handler, _nwords_in_file, _status, CLOSED, MSG::ERROR, INIT, MSG::NORMAL, OPENED, OPERATING, Message::send(), and MSG::WARNING.

Referenced by decoder_manager::decode(), pmt_slow_encoder::finalize(), decoder_manager::finalize(), main(), reset(), xmit_event_search::run(), and write_file().

00094                           {
00095   //
00096   // Only function that can assign CLOSED status.
00097   //
00098   switch(_status){
00099   case INIT:
00100     Message::send(MSG::ERROR,__FUNCTION__,"File not yet opened!");
00101     break;
00102   case CLOSED:
00103     Message::send(MSG::ERROR,__FUNCTION__,"File already closed!!");
00104     break;
00105   case OPENED:
00106     sprintf(_buf,"Closing: %s ... no I/O operation done.",_filename.c_str());
00107     Message::send(MSG::WARNING,__FUNCTION__,_buf);
00108     fclose(_handler);
00109     break;
00110   case OPERATING:
00111     sprintf(_buf,"Closing: %s ... %d words processed",
00112         _filename.c_str(),
00113         _nwords_in_file);
00114     Message::send(MSG::NORMAL,__FUNCTION__,_buf);
00115     fclose(_handler);
00116     break;
00117   }
00118   _handler=0;
00119   _status=CLOSED;
00120 }

bool bin_io_handler::eof (  )  const [inline]

A method to return if eof is reached or not.

Definition at line 69 of file bin_io_handler.hh.

References _eof.

Referenced by compare_content(), decoder_manager::decode(), main(), xmit_event_search::run(), and bin_word_search::run().

00069 {return _eof;};

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;};

bool bin_io_handler::is_open (  )  const

A method to check if a file is still in open state.

Definition at line 82 of file bin_io_handler.cc.

References _status, CLOSED, INIT, OPENED, and OPERATING.

Referenced by pmt_slow_encoder::initialize(), decoder_manager::initialize(), main(), xmit_event_search::run(), and bin_word_search::run().

00082                                   {
00083   switch(_status){
00084   case OPENED:
00085   case OPERATING:
00086     return true;
00087   case INIT:
00088   case CLOSED:
00089     break;
00090   }
00091   return false;
00092 }

bool bin_io_handler::open (  ) 

A method to open input/output file.

Definition at line 39 of file bin_io_handler.cc.

References decoder_base::_buf, _eof, _filename, _format, _handler, _mode, _status, FORMAT::ASCII, FORMAT::BINARY, MSG::ERROR, MSG::NORMAL, OPENED, OPERATING, READ, Message::send(), and FORMAT::UNDEFINED.

Referenced by compare_content(), decoder_manager::decode(), pmt_slow_encoder::initialize(), decoder_manager::initialize(), main(), decoder_manager::open_file(), xmit_event_search::run(), bin_word_search::run(), and write_file().

00039                          {
00040   //
00041   // Only function that can assign OPENED status
00042   //
00043   if(_filename.size()==0) {
00044     Message::send(MSG::ERROR,__FUNCTION__,
00045           "File name is empty. Provide a file path+name.");
00046   }else if(_status==OPENED || _status==OPERATING) {
00047     sprintf(_buf,
00048         "File is open: %s ... you must close it first.",
00049         _filename.c_str());
00050     Message::send(MSG::ERROR,__FUNCTION__,_buf);
00051   }else{
00052     switch(_format){
00053     case FORMAT::UNDEFINED:
00054       Message::send(MSG::ERROR, __FUNCTION__,
00055             "File format unspecified. Cannot open a file.");
00056       break;
00057     case FORMAT::BINARY:
00058       if(_mode==READ) _handler=fopen(_filename.c_str(),"rb");
00059       else            _handler=fopen(_filename.c_str(),"wb");
00060       break;
00061     case FORMAT::ASCII:
00062       if(_mode==READ) _handler=fopen(_filename.c_str(),"r");
00063       else            _handler=fopen(_filename.c_str(),"w");
00064       break;
00065     }
00066   }
00067 
00068   if(!(_handler)){
00069     sprintf(_buf,"Failed to open a file: %s",_filename.c_str());
00070     Message::send(MSG::ERROR,__FUNCTION__,_buf);
00071     return false;
00072   }
00073 
00074   sprintf(_buf,"Opened a file: %s",_filename.c_str());
00075   Message::send(MSG::NORMAL,__PRETTY_FUNCTION__,_buf);
00076 
00077   _eof = false;
00078   _status=OPENED;
00079   return true;
00080 }

PMT::word_t bin_io_handler::read_multi_word ( size_t  length = 0  ) 

Definition at line 170 of file bin_io_handler.cc.

References decoder_base::_buf, _eof, _format, _handler, _mode, _multi_word_index, _nchars, _nwords_in_file, _read_word_buffer, _status, decoder_base::_verbosity, decoder_base::_verbosity_level, _word, FORMAT::ASCII, MSG::DEBUG, PMT::EMPTY_WORD, MSG::ERROR, MSG::INFO, OPENED, OPERATING, READ, read_word(), Message::send(), and MSG::WARNING.

Referenced by decoder_manager::decode(), and xmit_event_search::run().

00170                                                       {
00171 
00172   _word = PMT::EMPTY_WORD;
00173   if(_status!=OPENED && _status!=OPERATING) {
00174     Message::send(MSG::ERROR,__FUNCTION__,
00175           "Invalid file I/O status. Cannot read!");
00176     return _word;
00177   }
00178 
00179   if(_mode!=READ){
00180     Message::send(MSG::ERROR,__FUNCTION__,
00181           "Not allowed as this is input file stream!");    
00182     return _word;
00183   }
00184 
00185   _status=OPERATING;
00186 
00187   // Check if a buffer holds words to be read out
00188   if(_multi_word_index < _read_word_buffer.size()) {
00189 
00190     _word = _read_word_buffer.at(_multi_word_index);
00191 
00192     _multi_word_index++;
00193 
00194     _nwords_in_file++;
00195 
00196     return _word;
00197   }
00198 
00199   if(feof(_handler)){
00200     Message::send(MSG::DEBUG,__FUNCTION__,"Reached EOF!");
00201     _eof=true;
00202     return PMT::EMPTY_WORD;
00203   }
00204 
00205   size_t nwords_to_read = length;
00206   size_t nwords_read    = 0;
00207   
00208   if(!(nwords_to_read)) nwords_to_read = read_word();
00209  
00210   if(_format==FORMAT::ASCII){
00211 
00212     _read_word_buffer.clear();
00213 
00214     _read_word_buffer.reserve(nwords_to_read);
00215 
00216     for(nwords_read=0; nwords_read<nwords_to_read && !_eof; nwords_read++){
00217 
00218       if(fscanf(_handler,"%x%n",&_word,&_nchars)<1) {
00219     Message::send(MSG::DEBUG,__FUNCTION__,"Reached EOF!");
00220     _eof=true;
00221       }
00222 
00223       while(!_eof && _nchars<8  ) {
00224     if(_verbosity_level<=MSG::WARNING){
00225       sprintf(_buf,"Encountered none 32-bit word expression: %x (%d chars)",_word,_nchars);
00226       Message::send(MSG::WARNING,__FUNCTION__,_buf);
00227     }
00228     
00229     _eof=feof(_handler);
00230     
00231     if(fscanf(_handler,"%x%n",&_word,&_nchars)<1) {
00232       _eof=true;
00233       break;
00234     }
00235       }
00236       
00237       if(!_eof) _read_word_buffer.push_back(_word);
00238     }
00239 
00240   }
00241   else{
00242 
00243     _read_word_buffer.clear();
00244     _read_word_buffer.resize(nwords_to_read,0);
00245     
00246     nwords_read=fread(&_read_word_buffer[0],sizeof(_word),nwords_to_read,_handler);
00247 
00248     if(nwords_read < nwords_to_read) {
00249 
00250       _eof = true;
00251 
00252       _read_word_buffer.resize(nwords_read);
00253 
00254     }
00255   }
00256 
00257   if(_verbosity[MSG::INFO]){
00258     
00259     sprintf(_buf,"Read-in %zu/%zu words from the file...",nwords_read,nwords_to_read);
00260     Message::send(MSG::INFO,__FUNCTION__,_buf);
00261   }
00262 
00263   _multi_word_index = 0;
00264 
00265   _word = _read_word_buffer[_multi_word_index];
00266 
00267   _multi_word_index++;
00268 
00269   return _word;
00270 }

PMT::word_t bin_io_handler::read_word (  ) 

Receive 32-bit word from this method in READ mode.

Definition at line 272 of file bin_io_handler.cc.

References decoder_base::_buf, _checksum, _eof, _format, _handler, _mode, _nchars, _nwords_in_file, _status, decoder_base::_verbosity_level, _word, FORMAT::ASCII, MSG::DEBUG, PMT::EMPTY_WORD, MSG::ERROR, OPENED, OPERATING, READ, Message::send(), and MSG::WARNING.

Referenced by compare_content(), decoder_manager::decode(), main(), read_multi_word(), xmit_event_search::run(), and bin_word_search::run().

00272                                     {
00273 
00274   if(_eof) return PMT::EMPTY_WORD;
00275 
00276   _word=PMT::EMPTY_WORD;
00277   _nchars=PMT::EMPTY_WORD;
00278 
00279   if(_status!=OPENED && _status!=OPERATING) {
00280     Message::send(MSG::ERROR,__FUNCTION__,
00281           "Invalid file I/O status. Cannot read!");
00282     return _word;
00283   }
00284 
00285   if(_mode!=READ){
00286     Message::send(MSG::ERROR,__FUNCTION__,
00287           "Not allowed as this is input file stream!");    
00288     return _word;
00289   }
00290 
00291   _status=OPERATING;
00292 
00293   //
00294   // Different handling for ASCII v.s. BIN
00295   //
00296   if(feof(_handler)){
00297     Message::send(MSG::DEBUG,__FUNCTION__,"Reached EOF!");
00298     _eof=true;
00299     return PMT::EMPTY_WORD;
00300   }
00301 
00302   // Check if fscanf returns < 1 ... then it is EOF
00303   if(_format==FORMAT::ASCII){
00304 
00305     if(fscanf(_handler,"%x%n",&_word,&_nchars)<1) {
00306       Message::send(MSG::DEBUG,__FUNCTION__,"Reached EOF!");
00307       _eof=true;
00308     }
00309 
00310     while(!_eof && _nchars<8  ) {
00311       if(_verbosity_level<=MSG::WARNING){
00312     sprintf(_buf,"Encountered none 32-bit word expression: %x (%d chars)",_word,_nchars);
00313     Message::send(MSG::WARNING,__FUNCTION__,_buf);
00314       }
00315 
00316       _eof=feof(_handler);
00317       
00318       if(fscanf(_handler,"%x%n",&_word,&_nchars)<1) {
00319     _eof=true;
00320     break;
00321       }
00322     }
00323   }
00324   else
00325     _eof=!(fread(&_word,sizeof(_word),1,_handler));
00326   
00327   if(_eof)
00328     _word=PMT::EMPTY_WORD;
00329   else{
00330     _checksum+=_word;
00331     _nwords_in_file+=1;
00332   }
00333 
00334   return _word;
00335 }

void bin_io_handler::reset (  ) 

A method to initialize the class instance.

Definition at line 15 of file bin_io_handler.cc.

References _eof, _filename, _format, _mode, _nwords_in_file, _single_word, _status, close(), CLOSED, INIT, OPENED, OPERATING, READ, and FORMAT::UNDEFINED.

Referenced by bin_io_handler(), and decoder_manager::reset().

00015                           {
00016   
00017   //
00018   // Only function that can assign INIT status other 
00019   // than the constructor.
00020   //
00021   switch(_status){
00022   case INIT:
00023   case CLOSED:
00024     break;
00025   case OPENED:
00026   case OPERATING:
00027     close();
00028     break;
00029   }  
00030   _filename="";
00031   _nwords_in_file=0;
00032   _mode=READ;
00033   _status=INIT;
00034   _format=FORMAT::UNDEFINED;
00035   _eof=false;
00036   _single_word[0]=0x0;
00037 }

void bin_io_handler::set_filename ( std::string  name  )  [inline]

Setter for input/output file name.

Definition at line 66 of file bin_io_handler.hh.

References _filename.

Referenced by compare_content(), decoder_manager::decode(), decoder_manager::initialize(), main(), xmit_event_search::set_filename(), pmt_slow_encoder::set_filename(), bin_word_search::set_filename(), and write_file().

00066 {_filename=name;};

void bin_io_handler::set_format ( FORMAT::INPUT_FILE  f  )  [inline]

Setter for the input file format defined in FORMAT::INPUT_FILE.

Definition at line 60 of file bin_io_handler.hh.

References _format.

Referenced by compare_content(), main(), xmit_event_search::set_format(), decoder_manager::set_format(), bin_word_search::set_format(), write_file(), and xmit_event_search::xmit_event_search().

00060 {_format=f;};

void bin_io_handler::set_mode ( MODE  mode  )  [inline]

Setter for I/O mode defined in bin_io_handler::MODE.

Definition at line 63 of file bin_io_handler.hh.

References _mode.

Referenced by compare_content(), main(), pmt_slow_encoder::set_mode(), write_file(), and xmit_event_search::xmit_event_search().

00063 {_mode=mode;};

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 }

bool bin_io_handler::write_multi_word ( const PMT::word_t *  words,
const size_t  entries 
)

Send an array of words to this method to write out in WRITE mode.

Definition at line 129 of file bin_io_handler.cc.

References _checksum, _format, _handler, _mode, _nchars, _nwords_in_file, _status, FORMAT::ASCII, MSG::ERROR, OPENED, OPERATING, Message::send(), and WRITE.

Referenced by pmt_slow_encoder::analyze(), write_file(), and write_word().

00129                                                                                  {
00130 
00131   //
00132   // Only function that can assign OPERATING status in WRITE mode.
00133   //
00134   if(_status!=OPENED && _status!=OPERATING) {
00135     Message::send(MSG::ERROR,__FUNCTION__,"Invalid file I/O status. Cannot write output!");
00136     return false;
00137   }
00138 
00139   if(_mode!=WRITE){
00140     Message::send(MSG::ERROR,__FUNCTION__,
00141           "Not allowed as this is output file stream!");
00142     return false;
00143   }
00144 
00145   if(_format==FORMAT::ASCII) {
00146 
00147     _nchars=0;
00148 
00149     for(UInt_t index=0; index<entries; ++index) {
00150       
00151       _nchars+=fprintf(_handler,"%x ",words[index]);
00152       
00153       _nwords_in_file++;
00154       
00155       _checksum+=words[index];
00156 
00157     }
00158 
00159     fprintf(_handler,"\n");
00160   }
00161   else {
00162     
00163     fwrite(&words[0],sizeof(PMT::word_t),entries,_handler);
00164 
00165   }
00166 
00167   return true;
00168 }

bool bin_io_handler::write_word ( const PMT::word_t  word  ) 

Send a word to this method to write out in WRITE mode.

Definition at line 122 of file bin_io_handler.cc.

References _single_word, and write_multi_word().

Referenced by write_file().

00122                                                     {
00123 
00124   _single_word[0]=word;
00125 
00126   return write_multi_word(_single_word,1);
00127 }

Member Data Documentation

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(), 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(), open(), storage_manager::prepare_tree(), pulse_viewer::previous_pulse(), algo_slow_readout_decoder::print_adc_values(), algo_tpc_xmit::process_ch_word(), algo_slow_readout_decoder::process_ch_word(), algo_pmt_xmit::process_ch_word(), algo_fem_decoder_base::process_fem_header(), algo_xmit_decoder::process_header(), algo_slow_readout_decoder::process_header(), algo_slow_readout_decoder::process_word(), read_multi_word(), read_word(), and ana_processor::run().

UInt_t bin_io_handler::_checksum [private]

checksum of operated 32-bit words

Definition at line 91 of file bin_io_handler.hh.

Referenced by read_word(), and write_multi_word().

bool bin_io_handler::_eof [private]

EOF boolean.

Definition at line 89 of file bin_io_handler.hh.

Referenced by eof(), open(), read_multi_word(), read_word(), and reset().

size_t bin_io_handler::_file_suffix [private]

A counter for file suffix in case output is too big.

Definition at line 92 of file bin_io_handler.hh.

std::string bin_io_handler::_filename [private]

Input/Output filename.

Definition at line 87 of file bin_io_handler.hh.

Referenced by close(), open(), reset(), and set_filename().

FORMAT::INPUT_FILE bin_io_handler::_format [private]

Input file format.

Definition at line 97 of file bin_io_handler.hh.

Referenced by open(), read_multi_word(), read_word(), reset(), set_format(), and write_multi_word().

FILE* bin_io_handler::_handler [private]

File handler pointer.

Definition at line 100 of file bin_io_handler.hh.

Referenced by close(), open(), read_multi_word(), read_word(), and write_multi_word().

MODE bin_io_handler::_mode [private]

I/O mode.

Definition at line 99 of file bin_io_handler.hh.

Referenced by open(), read_multi_word(), read_word(), reset(), set_mode(), and write_multi_word().

size_t bin_io_handler::_multi_word_index [private]

Definition at line 104 of file bin_io_handler.hh.

Referenced by read_multi_word().

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(), 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 bin_io_handler::_nchars [private]

Number of chars read in case of ASCII file.

Definition at line 96 of file bin_io_handler.hh.

Referenced by read_multi_word(), read_word(), and write_multi_word().

UShort_t bin_io_handler::_nwords_in_file [private]

Number of words read or written per file.

Definition at line 90 of file bin_io_handler.hh.

Referenced by close(), read_multi_word(), read_word(), reset(), and write_multi_word().

std::vector<PMT::word_t> bin_io_handler::_read_word_buffer [private]

Definition at line 103 of file bin_io_handler.hh.

Referenced by read_multi_word().

PMT::word_t bin_io_handler::_single_word[1] [private]

A place holder variable to process a single word.

Definition at line 94 of file bin_io_handler.hh.

Referenced by reset(), and write_word().

STATUS bin_io_handler::_status [private]

Process status flag.

Definition at line 98 of file bin_io_handler.hh.

Referenced by bin_io_handler(), close(), is_open(), open(), read_multi_word(), read_word(), reset(), and write_multi_word().

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

holder for enabled message levels

Definition at line 51 of file decoder_base.hh.

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

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

holder for specified verbosity level

Definition at line 52 of file decoder_base.hh.

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

PMT::word_t bin_io_handler::_word [private]

A word set to be read/write-out.

Definition at line 95 of file bin_io_handler.hh.

Referenced by read_multi_word(), and read_word().

The documentation for this class was generated from the following files:
Generated on Mon Apr 7 15:35:13 2014 for MyProject by  doxygen 1.4.7