HldProcessor.h

#ifndef HADAQ_HLDPROCESSOR_H
#define HADAQ_HLDPROCESSOR_H
 
#include "base/EventProc.h"
 
#include "hadaq/definess.h"
 
#include "hadaq/TrbProcessor.h"
 
namespace hadaq {
 
 
   typedef std::map<unsigned,TrbProcessor*> TrbProcMap;
 
   struct HldMessage {
      uint8_t trig_type; 
      uint32_t seq_nr;   
      uint32_t run_nr;   
 
      HldMessage() : trig_type(0), seq_nr(0), run_nr(0) {}
 
      HldMessage(const HldMessage& src) : trig_type(src.trig_type), seq_nr(src.seq_nr), run_nr(src.run_nr) {}
   };
 
   class HldSubEvent : public base::SubEvent {
      public:
         HldMessage fMsg;   
 
         HldSubEvent() : base::SubEvent(), fMsg() {}
         HldSubEvent(const HldMessage& msg) : base::SubEvent(), fMsg(msg) {}
         virtual ~HldSubEvent() {}
 
         virtual unsigned Multiplicity() const { return 1; }
   };
 
   class HldFilter : public base::EventProc {
      protected:
         unsigned fOnlyTrig;   
      public:
 
         HldFilter(unsigned trig = 0x1) : base::EventProc(), fOnlyTrig(trig) {}
 
         virtual ~HldFilter() {}
 
         virtual bool Process(base::Event* ev)
         {
            hadaq::HldSubEvent* sub =
                  dynamic_cast<hadaq::HldSubEvent*> (ev->GetSubEvent("HLD"));
 
            if (sub==0) return false;
 
            return sub->fMsg.trig_type == fOnlyTrig;
         }
   };
 
   class HldProcessor : public base::StreamProc {
 
      friend class TrbProcessor;
 
      protected:
 
         TrbProcMap fMap;            
 
         unsigned  fEventTypeSelect; 
 
         bool fPrintRawData;         
 
         bool fAutoCreate;           
         std::string fAfterFunc; 
 
         std::string fCalibrName;      
         long fCalibrPeriod;           
         unsigned fCalibrTriggerMask;  
 
         base::H1handle fEvType;       
         base::H1handle fEvSize;       
         base::H1handle fSubevSize;    
         base::H1handle fHitsPerTDC;   
         base::H1handle fErrPerTDC;    
         base::H2handle fHitsPerTDCChannel; 
         base::H2handle fErrPerTDCChannel;  
         base::H2handle fCorrPerTDCChannel; 
         base::H2handle fQaFinePerTDCChannel;  
         base::H2handle fQaToTPerTDCChannel;  
         base::H2handle fQaEdgesPerTDCChannel;  
         base::H2handle fQaErrorsPerTDCChannel;  
         base::H1handle fQaSummary;  
 
         HldMessage     fMsg;        
         HldMessage    *pMsg;        
 
         hadaqs::RawEvent  fLastEvHdr;    
 
         long fLastHadesTm;               
 
         virtual bool doTriggerSelection() const { return false; }
 
         void AddTrb(TrbProcessor* trb, unsigned id);
 
         virtual void CreateBranch(TTree*);
 
         virtual void Store(base::Event* ev);
         virtual void ResetStore();
 
         void CreatePerTDCHisto();
 
         void DoHadesHistSummary();
 
         void SetCrossProcess(bool on);
 
      public:
 
         HldProcessor(bool auto_create = false, const char* after_func = "");
         virtual ~HldProcessor();
 
         uint32_t GetEventId() const { return fMsg.seq_nr; }
         uint32_t GetRunId() const { return fMsg.run_nr; }
 
         unsigned NumberOfTDC() const;
         TdcProcessor* GetTDC(unsigned indx) const;
         TdcProcessor* FindTDC(unsigned tdcid) const;
 
         unsigned NumberOfTRB() const;
         TrbProcessor* GetTRB(unsigned indx) const;
         TrbProcessor* FindTRB(unsigned trbid) const;
 
         void ConfigureCalibration(const std::string& fileprefix, long period, unsigned trig = 0xFFFF);
 
         void SetEventTypeSelect(unsigned evid) { fEventTypeSelect = evid; }
 
         virtual void SetTriggerWindow(double left, double right);
 
         virtual void SetStoreKind(unsigned kind = 1);
 
         virtual bool FirstBufferScan(const base::Buffer& buf);
 
         void SetPrintRawData(bool on = true);
         bool IsPrintRawData() const { return fPrintRawData; }
 
         void SetAutoCreate(bool on = true) { fAutoCreate = on; }
 
         unsigned TransformEvent(void* src, unsigned len, void* tgt = 0, unsigned tgtlen = 0);
 
         virtual void UserPreLoop();
 
         hadaqs::RawEvent& GetLastEventHdr() { return fLastEvHdr; }
   };
 
}
 
#endif