onlinemonitor/rocmonitor/TRocProc.h (r4864/r3817)

Go to the documentation of this file.

#ifndef TROCPROC_H
#define TROCPROC_H

#include "roc/Iterator.h"

#include <vector>
#include <stdint.h>

#include "TCBMBeamtimeProc.h"

#include "roc/Message.h"
#include "roc/Board.h"

class TRocParam;
class TPedestalExtractor;
class TGo4MbsSubEvent;
class TGet4MessageFull;

#include "TRocEvent.h"
#include "TRocRec.h"
#include "TGet4Rec.h"


class TRocProc : public TCBMBeamtimeProc {
   public:
      TRocProc();
      TRocProc(const char* name);
      virtual ~TRocProc() ;

      virtual void InitEvent(TGo4EventElement * evt);

      virtual void ProcessSubevent(TGo4MbsSubEvent* subevt);

      virtual void FinalizeEvent();

   protected:

      virtual void ProcessNxHit(roc::Message* msg, Double_t nxadc_corr) {}

      void ProcessExtendedMessage(unsigned rocid, TRocData* rocevent, TRocMessageExtended& msg, bool with_unprocessed = true);

      void ProcessTriggerMessage(TRocData* rocevent, int rocid, uint64_t fulltm);
      
      void HandleUnprocessedMessages(TRocData* rocevent, int rocid);

      void LoadPedestalFile(const char* fname);
      void SavePedestalFile(const char* fname);

      Bool_t ProcessGet4EpochMessage(UInt_t uRocId, TRocData* rocEvent, UInt_t uGet4IndexOffset, roc::Message* mesData);
      Bool_t ProcessGet4DataMessage(UInt_t uRocId, UInt_t uGet4IndexOffset, roc::Message* mesData);
      Bool_t ProcessGet4ExtSyncMessage(UInt_t uGet4IndexOffset, roc::Message* mesData);
      Bool_t TimeOrderMessageBuffer( TRocData* rocToSort);
      
      Bool_t PrintRocEpochIndexes(Int_t uMessagePriority = 0);
      Bool_t PrintRocEpochCycles(Int_t uMessagePriority = 0);
      Bool_t PrintLocalEpochIndexes(Int_t uMessagePriority = 0);
      Bool_t PrintLocalEpochCycles(Int_t uMessagePriority = 0);
      Bool_t PrintUnsynchronizedEpochCount(Int_t uMessagePriority = 0);
      Bool_t PrintTotalUnsynchronizedEpochCount(Int_t uMessagePriority = 0);
      Bool_t PrintMessageBufferIndexes(Int_t uMessagePriority = 0);
      Bool_t PrintMessageBufferSizes(Int_t uMessagePriority = 0);

      /* after event completion reset until next triggers are found*/
      void ResetTrigger();

      /* after all input buffers are done, we reset end of buffer flag*/
      void ResetEndOfBuffer();

      //      /* subfunction which is called when trigger window is fullfilled.*/
      //      void ProcessTriggeredData(TRocMessageExtended& msg);

      Bool_t AssertRoc(unsigned rocid)
      {
         if(rocid >= MAX_ROC) return kFALSE;
         if(TRocEvent::ConfigRocs[rocid]==0) return kFALSE;
         return kTRUE;
      }

      Bool_t AssertNX(unsigned nxid)
      {
         if(nxid < MAX_NX) return nx_use_mask[nxid];
         return kFALSE;
      }

      Bool_t AssertGET4(unsigned indx)
      {
         if (indx < MAX_GET4) return get4_use_mask[indx];
         return kFALSE;
      }


      TRocParam     *fParam;

//      roc::Iterator & fIter;
//      roc::Iterator fDefaultIter;

      TPedestalExtractor *fPedestals;

      Bool_t fIsTimeSorted; // true if messages within mbs container are strictly time sorted

      unsigned       fNumRocs;

      bool           nx_use_mask[MAX_NX];

      bool           get4_use_mask[MAX_GET4];

      TH1           *fEvntSize;

      TH1           *fAUX2_R01; // difference between AUX2 signals on ROC0 and ROC1

      TH1           *fSYNC_R0_R10; // difference between SYNC0 on ROC10 - SYNC1 on ROC0

      TH1           *fMsgsPerRoc;
      TH1           *fTriggerPerRoc;

      TH1* fDeltaTriggerTime; // absolute time difference of all hits with respect to global trigger
      TGo4WinCond* fGlobalTriggerWind; // time window to assign hits to output event (relative to last global trigger)
      TGo4WinCond* fGlobalAUXWind; // time window to assign AUX to output event (relative to last global trigger)

      ULong_t fTotaldatasize;

      UInt_t         fCurrEvntTm;

      Double_t       fLastRateTm; // last time of rate measurement
      Double_t       fRate;       // currently calculated rate

      std::vector<TRocRec> ROC;  
      TRocEvent * fOutputEvent;  
      Bool_t fFirstSubEvent;     

      Bool_t fHasNewGlobalTrigger; 
      unsigned fTriggerCounter; 
      

      std::vector<TGet4Rec> FECHIP;        
      // General counters (allow for example event jumps by stream server)
      UInt_t     printData;
      UInt_t     uNbEvents[MAX_ROC];
      UInt_t     uFirstEventIndex[MAX_ROC];
      UInt_t     uPrevEventIndex[MAX_ROC];
      
      // Intermediate event buffer for later splitting analysis
      std::vector< std::vector<TRocMessageExtended> > vMessageInterBuffer;
      std::vector<TRocMessageExtended>                vMessageEventBuffer;
      UInt_t uCurrentBlockBuffer;      // unsigned integer giving which buffer to use when
                                       // sorting hits from a chip  
      Bool_t bTransferMessageNext;
      UInt_t  uEpochBufferStart; // Start of each message buffer
      UInt_t  uCycleBufferStart; // Start of each message buffer  

      // buffer of not validated hit messages from previous MBS events which could match new trigger
      std::vector< std::vector<TRocMessageExtended> > vMessageInterBufferUnprocessed;
      std::vector< std::vector<TRocMessageExtended> > vUnprocessedMessages;
      
      // Variables
      UInt_t     uLastEpochMainClock; // Main 250MHz clock epoch counter
      UInt_t     uMainEpochCycle;     // Main 250MHz clock epoch counter cycle
      UInt_t     uCurrentEpoch2;     // Last Epoch Nb from ROC message (global)
      UInt_t     uCurrentCycle2;     // Last Epoch Cycle Nb from ROC message (global)
         // Automatic GET4 chip failure detection
      UInt_t     uRocEpochFirstSyncedChip;
      UInt_t     uRocCycleFirstSyncedChip;
         // GET4 reset recovery
      ULong64_t  uEpochFirstSyncAfterReset;
      UInt_t     uCycleFirstSyncAfterReset;
      
      // Histograms
      TH1 *fGet4SynchChip;           // Get4 System Ext synch chip
      TH1 *fGet4ErrorChip;           // Get4 System Error chip
      TH2 *fGet4SynchPatt;           // Get4 System Ext synch pattern
      TH2 *fGet4ErrorPatt;           // Get4 System Error pattern
      
      TH1 *fGet4DataLoss;            // Epochs with data Loss
      TH1 *fGet4EpochLoss;           // Epochs with Loss of Epochs in ROC buffer      
      TH2 *fNbMissedSync;
      
      TH2 *fGet4EdgeMessagePerRawEvent; // Nb of accepted edge message per event
      TH2 *fGet4NotValidMessRawEvent;   // Nb of not validated accepted edge message per event

      TH1 *fGet4RisEdgesNb;          // Nb of rising  edges for each channel
      TH1 *fGet4FalEdgesNb;          // Nb of falling edges for each channel
      TH2 *fGet4EdgesDiffEvol;       // diff nb of rising & falling edges for each cycle/channel
      TH1 *fGet4RisEdgesEvol;        // Total nb of rising  edges for each cycle
      TH1 *fGet4FalEdgesEvol;        // Total nb of falling edges for each cycle

      TH2 *fMapEpochsMain;
      TH2 *fMapEpochsRoc;
      TH2 *fMapEpochsLocal;
      TH1 *fDistribEpochsMain;
      TH2 *fDistribEpochsRoc;
      TH2 *fDistribEpochsLocal;
      
      // Automatic GET4 chip failure detection
      TH2 *fInterChipSyncEpochShift; // Inter chip epoch shift check
      
      // Control over Automatic reset
      UInt_t uIndexResetGet4; // AUTO reset

   private:

      /*#  TRocRec lnkTRocRec; */
      /*#  TGet4Rec lnkTGet4Rec; */


      ClassDef(TRocProc,1)
};

#endif //TUNPACKPROCESSOR_H