TrbProcessor.h

#ifndef HADAQ_TRBPROCESSOR_H
#define HADAQ_TRBPROCESSOR_H
 
#include "base/StreamProc.h"
//#include "base/Profiler.h"
#include "hadaq/definess.h"
#include "hadaq/TdcProcessor.h"
#include "hadaq/SubProcessor.h"
 
#include <vector>
 
namespace hadaq {
 
   class HldProcessor;
 
   struct TrbMessage {
      bool fTrigSyncIdFound;              
      unsigned fTrigSyncId;               
      unsigned fTrigSyncIdStatus;         
      uint64_t fTrigTm;                   
      unsigned fSyncPulsePeriod;          
      unsigned fSyncPulseLength;          
 
      void Reset()
      {
         fTrigSyncIdFound = false;
         fTrigSyncId = 0;
         fTrigTm = 0;
         fTrigSyncIdStatus = 0;
         fSyncPulsePeriod = 0;
         fSyncPulseLength = 0;
      }
   };
 
   class TrbProcessor : public base::StreamProc {
 
      friend class TdcProcessor;
      friend class SubProcessor;
      friend class HldProcessor;
 
      protected:
 
         HldProcessor *fHldProc{nullptr};     
 
         SubProcMap fMap;            
 
         unsigned fHadaqCTSId{0};       
         std::vector<unsigned> fHadaqHUBId;   
 
         unsigned fLastTriggerId{0};    
         unsigned fLostTriggerCnt{0};   
         unsigned fTakenTriggerCnt{0};  
 
         base::H1handle fEvSize{nullptr};     
         unsigned fSubevHLen{0};        
         unsigned fSubevHDiv{0};        
         base::H1handle fSubevSize{nullptr};  
         base::H1handle fLostRate{nullptr};   
         base::H1handle fTrigType{nullptr};   
         base::H1handle fErrBits{nullptr};    
 
         base::H1handle fMsgPerBrd{nullptr};  
         base::H1handle fErrPerBrd{nullptr};  
         base::H1handle fHitsPerBrd{nullptr}; 
         base::H2handle fCalHitsPerBrd{nullptr}; 
         base::H2handle fToTPerBrd{nullptr};  
 
 
         bool fPrintRawData;         
         bool fCrossProcess;         
         int  fPrintErrCnt;          
 
         unsigned fSyncTrigMask;       
         unsigned fSyncTrigValue;      
         unsigned fCalibrTriggerMask;  
 
         bool fUseTriggerAsSync;     
 
         bool fCompensateEpochReset;  
 
         bool fAutoCreate;            
 
         TrbMessage  fMsg;            
         TrbMessage* pMsg{nullptr};    
 
//         base::Profiler  fProfiler;   ///< profiler
 
         unsigned fMinTdc;         
         unsigned fMaxTdc;         
         std::vector<hadaq::TdcProcessor*> fTdcsVect; 
 
         hadaqs::RawSubevent   fLastSubevHdr; 
         unsigned fCurrentRunId;           
         unsigned fCurrentEventId;         
 
         static unsigned gNumChannels;     
         static unsigned gEdgesMask;       
         static bool gIgnoreSync;          
 
         static unsigned gTDCMin;          
         static unsigned gTDCMax;          
 
         static unsigned gHUBMin;          
         static unsigned gHUBMax;          
 
         virtual bool doTriggerSelection() const { return false; }
 
         void AccountTriggerId(unsigned id);
 
         void AddSub(SubProcessor* tdc, unsigned id);
 
         virtual void ScanSubEvent(hadaqs::RawSubevent* sub, unsigned trb3runid, unsigned trb3seqid);
 
         void BeforeEventScan();
 
         void AfterEventScan();
         void AfterEventFill();
 
         void BuildFastTDCVector();
 
         virtual void CreateBranch(TTree* t);
 
         void EventError(const char *msg);
         void EventLog(const char *msg);
 
         void SetCrossProcessAll();
 
      public:
 
         TrbProcessor(unsigned brdid = 0, HldProcessor *hld = nullptr, int hfill = -1);
         virtual ~TrbProcessor();
 
         HldProcessor *GetHLD() const { return fHldProc; }
 
         void SetAutoCreate(bool on = true) { fAutoCreate = on; }
 
         void SetHadaqCTSId(unsigned id) { fHadaqCTSId = id; }
 
         void AddHadaqHUBId(unsigned id) { fHadaqHUBId.emplace_back(id); }
 
         void SetHadaqHUBId(unsigned id1, unsigned id2=0, unsigned id3=0, unsigned id4=0)
         {
            fHadaqHUBId.clear();
            AddHadaqHUBId(id1);
            if (id2!=0) AddHadaqHUBId(id2);
            if (id3!=0) AddHadaqHUBId(id3);
            if (id4!=0) AddHadaqHUBId(id4);
         }
 
         void SetHadaqTDCId(unsigned) {}
         void SetHadaqSUBId(unsigned) {}
 
         virtual void UserPreLoop();
         virtual void UserPostLoop();
 
         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) { fPrintRawData = on; }
 
         bool IsPrintRawData() const { return fPrintRawData; }
 
         void SetPrintErrors(int cnt = 100) { fPrintErrCnt = cnt; }
         bool CheckPrintError();
 
         void SetCrossProcess(bool on = true);
         bool IsCrossProcess() const { return fCrossProcess; }
 
         void SetCh0Enabled(bool on = true);
 
         void SetSyncIds(unsigned mask, unsigned value)
         {
            fSyncTrigMask = mask;
            fSyncTrigValue = value;
         }
 
         void SetUseTriggerAsSync(bool on = true) { fUseTriggerAsSync = on; }
         bool IsUseTriggerAsSync() const { return fUseTriggerAsSync; }
 
         void SetCompensateEpochReset(bool on = true) { fCompensateEpochReset = on; }
 
         unsigned NumSubProc() const { return fMap.size(); }
 
         SubProcessor* GetSubProc(unsigned indx) const
         {
            for (SubProcMap::const_iterator iter = fMap.begin(); iter!=fMap.end(); iter++) {
               if (indx==0) return iter->second;
               indx--;
            }
            return 0;
         }
 
         TdcProcessor* GetTDC(unsigned tdcid, bool fullid = false) const
         {
            SubProcMap::const_iterator iter = fMap.find(tdcid);
 
            // for old analysis, where IDs are only last 8 bit
            if ((iter == fMap.end()) && !fullid) iter = fMap.find(tdcid & 0xff);
 
            // ignore integrated TDCs, they have upper 16bits set
            return ((iter != fMap.end()) && ((iter->first >> 16) == 0) && iter->second->IsTDC()) ? (TdcProcessor*) iter->second : 0;
         }
 
         unsigned NumberOfTDC() const
         {
            unsigned num = 0;
            for (SubProcMap::const_iterator iter = fMap.begin(); iter!=fMap.end(); iter++) {
               if (iter->second->IsTDC()) num++;
            }
            return num;
         }
 
         TdcProcessor* GetTDCWithIndex(unsigned indx) const
         {
            for (SubProcMap::const_iterator iter = fMap.begin(); iter!=fMap.end(); iter++) {
               if (!iter->second->IsTDC()) continue;
               if (indx == 0) return (TdcProcessor*) iter->second;
               indx--;
            }
            return 0;
         }
 
         void AddBufferToTDC(
               hadaqs::RawSubevent* sub,
               hadaq::SubProcessor* tdcproc,
               unsigned ix,
               unsigned datalen);
 
         TdcProcessor* FindTDC(unsigned tdcid) const;
 
         static void SetDefaults(unsigned numch=65, unsigned edges=0x1, bool ignore_sync = true);
 
         static unsigned GetDefaultNumCh();
 
         static void SetTDCRange(unsigned min, unsigned max)
         {
            gTDCMin = min;
            gTDCMax = max;
         }
 
         static void SetHUBRange(unsigned min, unsigned max)
         {
            gHUBMin = min;
            gHUBMax = max;
         }
 
         int CreateTDC(unsigned id1, unsigned id2 = 0, unsigned id3 = 0, unsigned id4 = 0);
 
         void CreateCTS_TDC() { new hadaq::TdcProcessor(this, fHadaqCTSId, gNumChannels, gEdgesMask); }
 
         void DisableCalibrationFor(unsigned firstch, unsigned lastch = 0);
 
         void SetAutoCalibrations(long cnt = 100000);
 
         void SetWriteCalibrations(const char* fileprefix, bool every_time = false, bool use_linear = false);
 
         bool LoadCalibrations(const char* fileprefix);
 
         void ConfigureCalibration(const std::string& name, long period, unsigned trigmask = 0xFFFF);
 
         void SetCalibrTriggerMask(unsigned trigmask = 0xFFFF);
 
         bool CollectMissingTDCs(hadaqs::RawSubevent *sub, std::vector<unsigned> &ids);
 
         void ClearFastTDCVector();
 
         unsigned TransformSubEvent(hadaqs::RawSubevent *sub, void *tgtbuf = nullptr, unsigned tgtlen = 0, bool only_hist = false, std::vector<unsigned> *newids = nullptr);
 
         unsigned EmulateTransform(hadaqs::RawSubevent *sub, int dummycnt, bool only_hist = false);
 
         void CreatePerTDCHistos();
 
         bool HasPerTDCHistos() const { return (fHitsPerBrd != nullptr) && (fToTPerBrd != nullptr); }
 
         void ClearDAQHistos();
 
         hadaqs::RawSubevent& GetLastSubeventHdr() { return fLastSubevHdr; }
 
         hadaq::TrbMessage &GetTrbMsg() { return fMsg; }
   };
}
 
#endif