newmonitor/base/StreamProc.h (r3879/r3878)

Go to the documentation of this file.

#ifndef BASE_STREAMPROC_H
#define BASE_STREAMPROC_H

#include <vector>

#include <string>

#include "base/Buffer.h"
#include "base/SubEvent.h"

namespace base {

   class ProcMgr;
   class Event;

   typedef void* H1handle;
   typedef void* H2handle;
   typedef void* C1handle;


   struct SyncMarker {
      unsigned      uniqueid;    
      unsigned      localid;     
      LocalStamp_t  local_stamp; 
      GlobalTime_t  localtm;     
      GlobalTime_t  globaltm;    
      unsigned      bufid;       

      SyncMarker() : uniqueid(0), localid(0), local_stamp(0), localtm(0.), globaltm(0.), bufid(0) {}
   };


   struct LocalTriggerMarker {
      GlobalTime_t localtm;     
      unsigned      localid;     
      unsigned      bufid;       

      LocalTriggerMarker() : localtm(0.), localid(0), bufid(0) {}
   };


   struct GlobalTriggerMarker {
      GlobalTime_t globaltm;     
      GlobalTime_t lefttm;       
      GlobalTime_t righttm;      

      SubEvent*     subev;        
      bool          isflush;      

      GlobalTriggerMarker(GlobalTime_t tm = 0.) :
         globaltm(tm), lefttm(0.), righttm(0.), subev(0), isflush(false) {}

      GlobalTriggerMarker(const GlobalTriggerMarker& src) :
         globaltm(src.globaltm), lefttm(src.lefttm), righttm(src.righttm), subev(src.subev), isflush(src.isflush) {}

      ~GlobalTriggerMarker() {  }

      bool null() const { return globaltm<=0.; }
      void reset() { globaltm = 0.; isflush = false; }

      bool normal() const { return !isflush; }

      void SetInterval(double left, double right);

      int TestHitTime(const GlobalTime_t& hittime, double* dist = 0);
   };


   typedef std::vector<base::GlobalTriggerMarker> GlobalTriggerMarksQueue;


   class StreamProc {
      friend class ProcMgr;

      protected:

         typedef std::vector<base::Buffer> BuffersQueue;

         typedef std::vector<base::SyncMarker> SyncMarksQueue;

         typedef std::vector<base::LocalTriggerMarker> LocalTriggerMarksQueue;

         std::string fName;                       

         ProcMgr*   fMgr;                         

         BuffersQueue fQueue;                     

         unsigned     fQueueScanIndex;            
         unsigned     fQueueScanIndexTm;          

         bool            fIsSynchronisationRequired; 
         SyncMarksQueue  fSyncs;                  
         unsigned        fSyncScanIndex;          
         bool            fSyncFlag;               

         LocalTriggerMarksQueue fLocalTrig;       

         GlobalTriggerMarksQueue fGlobalTrig;     

         unsigned fGlobalTrigScanIndex;           
         unsigned fGlobalTrigRightIndex;          

         bool fTimeSorting;                       

         std::string   fPrefix;                   
         std::string   fSubPrefixD;               
         std::string   fSubPrefixN;               

         base::H1handle fTriggerTm;  
         base::H1handle fMultipl;    

         base::C1handle triggerWindow;   

         StreamProc(const char* name = "", int indx = -1);

         void SetSubPrefix(const char* subname = "", int indx = -1, const char* subname2 = "", int indx2 = -1);

         H1handle MakeH1(const char* name, const char* title, int nbins, double left, double right, const char* xtitle = 0);
         void FillH1(H1handle h1, double x, double weight = 1.);

         H2handle MakeH2(const char* name, const char* title, int nbins1, double left1, double right1, int nbins2, double left2, double right2, const char* options = 0);
         void FillH2(H1handle h2, double x, double y, double weight = 1.);

         C1handle MakeC1(const char* name, double left, double right, H1handle h1 = 0);
         void ChangeC1(C1handle c1, double left, double right);
         int TestC1(C1handle c1, double value, double* dist = 0);
         double GetC1Limit(C1handle c1, bool isleft = true);

         void AddSyncMarker(SyncMarker& marker);

         void AddTriggerMarker(LocalTriggerMarker& marker);

         double local_time_dist(GlobalTime_t tm1, GlobalTime_t tm2) { return tm2-tm1; }

         GlobalTime_t LocalToGlobalTime(GlobalTime_t localtm, unsigned* lastindx = 0);

         virtual bool doTriggerSelection() const { return false; }

         virtual GlobalTime_t ProvidePotentialFlushTime(GlobalTime_t last_marker);

         bool VerifyFlushTime(const base::GlobalTime_t& flush_time);

         virtual double MaximumDisorderTm() const { return 0.; }

         unsigned TestHitTime(const base::GlobalTime_t& hittime, bool normal_hit);

         virtual unsigned GetTriggerMultipl(unsigned indx) { return 0; }

         virtual void SortDataInSubEvent(base::SubEvent*) {}

      public:

         virtual ~StreamProc();

         //  void AssignMgr(ProcMgr* m) { fMgr = m; }
         ProcMgr* mgr() const { return fMgr; }

         const std::string GetProcName() const { return fName; }

         void SetTimeSorting(bool on) { fTimeSorting = on; }
         bool IsTimeSorting() const { return fTimeSorting; }


         void SetTriggerWindow(double left, double right)
         {
            ChangeC1(triggerWindow, left, right);
         }


         bool IsSynchronisationRequired() const { return fIsSynchronisationRequired; }

         virtual bool AddNextBuffer(const Buffer& buf);

         virtual bool ScanNewBuffers();

         virtual bool ScanNewBuffersTm();

         virtual void SkipAllData();

         virtual bool SkipBuffers(unsigned cnt);


         virtual bool FirstBufferScan(const base::Buffer& buf) { return false; }

         virtual bool SecondBufferScan(const base::Buffer& buf) { return false; }

         unsigned numSyncs() const { return fSyncs.size(); }
         SyncMarker& getSync(unsigned n) { return fSyncs[n]; }
         SyncMarker& lastSync() { return fSyncs[fSyncs.size()-1]; }
         bool eraseSyncAt(unsigned indx);

         virtual bool CollectTriggers(GlobalTriggerMarksQueue& queue);

         virtual bool DistributeTriggers(const GlobalTriggerMarksQueue& queue);

         virtual bool ScanDataForNewTriggers();

         unsigned NumReadySubevents() const { return fGlobalTrigScanIndex; }

         virtual bool AppendSubevent(base::Event* evt);
   };

}

#endif