algo_fem_decoder_base.hh

Go to the documentation of this file.

#ifndef ALGO_FEM_DECODER_BASE_HH
#define ALGO_FEM_DECODER_BASE_HH

#include "algo_base.hh"

class algo_fem_decoder_base : public algo_base {

public:

  struct InfoFEM_t {

    PMT::word_t module_address;      
    PMT::word_t module_id;           
    PMT::word_t event_id;            
    PMT::word_t event_frame_id;      
    PMT::word_t trigger_frame_id;    
    PMT::word_t trigger_timeslice;   
    PMT::word_t nwords;              
    PMT::word_t checksum;            
    bool        quality;             

    void clear_event(){
      
      module_address    = PMT::INVALID_WORD;
      module_id         = PMT::INVALID_WORD;
      event_id          = PMT::INVALID_WORD;
      event_frame_id    = PMT::INVALID_WORD;
      trigger_frame_id  = PMT::INVALID_WORD;
      trigger_timeslice = PMT::INVALID_WORD;
      nwords            = 0;
      checksum          = 0;
      quality           = true;
    }

    InfoFEM_t(){ clear_event(); }

  };

public:
  
  algo_fem_decoder_base();
  
  virtual ~algo_fem_decoder_base(){};

  virtual bool process_word(const PMT::word_t word);

  virtual inline PMT::PMT_WORD get_word_class(const PMT::word_t word) const {
    if     ( (word & 0xf000) == 0xf000 )
      return PMT::FEM_HEADER;
    else if( (word & 0xf000) == 0x4000 )
      return PMT::FEM_FIRST_WORD;
    else if( (word & 0xf000) == 0x9000 )
      return PMT::CHANNEL_HEADER;
    else if( (word & 0xf000) == 0xa000 )
      return PMT::CHANNEL_WORD;
    else if( (word & 0xf000) == 0xb000 )
      return PMT::CHANNEL_LAST_WORD;
    else if( (word & 0xf000) == 0xc000 )
      return PMT::FEM_LAST_WORD;
    else
      return PMT::UNDEFINED_WORD;
  }

  virtual bool check_event_quality(){return true;};

  virtual void reset();

  PMT::word_t round_diff(PMT::word_t ref_id, PMT::word_t subject_id, PMT::word_t diff) const;

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

protected:

  virtual bool store_event()=0;

  virtual void clear_event(){_event_header_count=0; _header_info.clear_event();};

  virtual bool process_fem_header(const PMT::word_t word, PMT::word_t &last_word);

  virtual bool decode_fem_header(const PMT::word_t *event_header);

  virtual bool process_event_header(const PMT::word_t word, PMT::word_t &last_word)=0;

  virtual bool process_ch_word(const PMT::word_t word, 
                   PMT::word_t &last_word) = 0;

  virtual bool process_fem_last_word(const PMT::word_t word,
                     PMT::word_t &last_word) = 0;

  virtual bool process_event_last_word(const PMT::word_t word,
                       PMT::word_t &last_word) = 0;

  virtual bool add_huffman_adc(std::vector<UShort_t> &wf, size_t zero_count);

  //
  // Constants
  //
  // Comment out the following if you deal with an older format with 1 less header
#define INCLUDE_EXTRA_HEADER
#ifdef INCLUDE_EXTRA_HEADER
  static const size_t FEM_HEADER_COUNT=6; 
#else
  static const size_t FEM_HEADER_COUNT=5; 
#endif

  // variables
  PMT::word_t          _event_header_words[FEM_HEADER_COUNT]; 

  //
  // Run control variable
  //
  PMT::word_t   _last_word;              
  size_t        _event_header_count;     

  bool          _search_for_next_event;  
  InfoFEM_t     _header_info;
};

#endif
 // end of doxygen group 

---