onlinemonitor/rocmonitor/TRocEvent.h (r4864/r3440)

Go to the documentation of this file.

#ifndef TROCEVENT_H
#define TROCEVENT_H

#include "TGo4EventElement.h"
#include "TGo4CompositeEvent.h"
#include <vector>

/*
 * Put all definitions here and use them in processor,
 * since they are necessary for data structure of event
 */

#include "roc/Message.h"

#include "TGet4MessageFull.h"

/*************************************/
      
// number of maximum connected ROCs
#define MAX_ROC           15

// maximum number of FEET board, connected to ROC
#define MAX_FEET          7

// maximum number of GET4 chips, connected to ROC
#define MAX_GET4          14

#define MAX_NX            4
// nxyters per roc 

#define MAX_GET4_NUM 2
// maximum get4 devices per roc
#define MAX_GET4_CH  4
// channels per get4

#define NB_BIN_GET4 128

#define MAX_AUX 4

#define MAX_SYNC 2

#define NUM_NXCHANNELS 128

// rocs id:                0  1  2  3  4  5  6  7  8  9 10 11 12 13 14
//                              |  |  |  |  |  |  |  |  |  |  |  |  |  |  |
#define SET_ROCS             {1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
// set 0 for roc of id not existing, otherwise 1

#include <stdint.h>

/*
 * Extended message container. Keeps original ROC message, but adds full timestamp and
 * optionally corrected adc valules.
 * Note that extended messages inside the vector will be sorted after full timestamp
 * by the TRocProc::FinalizeEvent
 *
 */
class TRocMessageExtended
{
   public:

      TRocMessageExtended(const roc::Message& msg, uint64_t fulltime=0, float adccorr=0.) :
         fxMessage(msg),
         ffCorrectedADC(adccorr),
         fuFulltime(fulltime),
         ffTriggerDeltaT(0),
         uRocEpoch( 0 )
      {
      }

      TRocMessageExtended() :
         fxMessage(),
         ffCorrectedADC(0.),
         fuFulltime(0),
         ffTriggerDeltaT(0),
         uRocEpoch( 0 )
      {
      }

      TRocMessageExtended(const TRocMessageExtended& src)
      {
         assign(src);
      }

      virtual ~TRocMessageExtended(){}

      /* this is used for timesorting the messages in the filled vectors */
      bool operator<(const TRocMessageExtended &rhs) const
         { return (fuFulltime < rhs.fuFulltime); }

      void SetRocMessage(const roc::Message & source)
      {
         fxMessage=source;
      }

      const roc::Message& GetRocMessage() const
      {
         return fxMessage;
      }

      uint8_t GetMessageType() const
      {
          return fxMessage.getMessageType();
      }
      void SetCorrectedNxADC(float val)
      {
         ffCorrectedADC=val;
      }

      float GetCorrectedNxADC() const
      {
         return ffCorrectedADC;
      }

      float GetNxADC() const
      {
         return  fxMessage.getNxAdcValue();
      }

      void SetFullTime(uint64_t ts)
      {
         fuFulltime=ts;
      }

      uint64_t GetFullTime() const
      {
         return fuFulltime;
      }

      uint16_t GetRocNumber() const
      {
          return fxMessage.getRocNumber();
      }


      Byte_t GetNxNumber() const
      {
         return fxMessage.getNxNumber();
      }

      Byte_t GetNxChNum() const
      {
         return fxMessage.getNxChNum();
      }

      uint8_t GetGet4Number() const
      {
         return fxMessage.getGet4Number();
      }


      uint8_t GetGet4ChNum() const
      {
         return fxMessage.getGet4ChNum();
      }

      uint32_t GetGet4Ts() const
      {
         return fxMessage.getGet4Ts();
      }

      Bool_t IsRisingGet4Edge() const
      {
         return fxMessage.getGet4Edge();
      }

      void SetTriggerDeltaT(float dt)
      {
         ffTriggerDeltaT=dt;
      }

      float GetTriggerDeltaT() const
      {
        return ffTriggerDeltaT;
      }

      Bool_t SetGet4MessageFull( const roc::Message & DataMessIn, UInt_t rocEpochIn,
            UInt_t rocCycleIn, UInt_t localEpochIn,
            UInt_t localCycleIn, Bool_t bUseLocal)
      {
         fxMessage        = DataMessIn;
         uRocEpoch        = rocEpochIn;
         uRocEpochCycle   = rocCycleIn;

         uLocalEpoch      = localEpochIn;
         uLocalEpochCycle = localCycleIn;

         if(kTRUE == bUseLocal)
         {
            if( roc::MSG_GET4 == fxMessage.getMessageType() )
               fuFulltime = fxMessage.getMsgFullTime( uLocalEpoch );
            else if(roc::MSG_SYS == fxMessage.getMessageType() &&
                    roc::SYSMSG_GET4_EVENT == fxMessage.getSysMesType() )
               fuFulltime = fxMessage.FullTimeStamp2(uLocalEpoch, (fxMessage.getField(23,12)<<7) )
                            / 20 + 512;
         }
         else
         {
            if( roc::MSG_GET4 == fxMessage.getMessageType() )
               fuFulltime = fxMessage.getMsgFullTime( uRocEpoch );
            else if(roc::MSG_SYS == fxMessage.getMessageType() &&
                    roc::SYSMSG_GET4_EVENT == fxMessage.getSysMesType() )
               fuFulltime = fxMessage.FullTimeStamp2(uRocEpoch, (fxMessage.getField(23,12)<<7) )
                            / 20 + 512;
         }

         return kTRUE;
      }

      Bool_t SetRocEpoch( UInt_t rocEpochIn)
      {
         uRocEpoch        = rocEpochIn;
         if( roc::MSG_GET4 == fxMessage.getMessageType() )
            fuFulltime = fxMessage.getMsgFullTime( uRocEpoch );
         else if(roc::MSG_SYS == fxMessage.getMessageType() &&
                 roc::SYSMSG_GET4_EVENT == fxMessage.getSysMesType() )
            fuFulltime = fxMessage.FullTimeStamp2(uRocEpoch, (fxMessage.getField(23,12)<<7) )
                         / 20 + 512;
         return kTRUE;
      }
      Bool_t SetRocCycle( UInt_t rocCycleIn)
      {
         uRocEpochCycle   = rocCycleIn;
         return kTRUE;
      }
      Bool_t SetLocalEpoch( ULong64_t localEpochIn)
      {
         uLocalEpoch      = localEpochIn;
         return kTRUE;
      }
      Bool_t SetLocalCycle( UInt_t localCycleIn)
      {
         uLocalEpochCycle = localCycleIn;
         return kTRUE;
      }

      UInt_t GetRocEpoch() const
      {
         return uRocEpoch;
      }
      UInt_t GetRocCycle() const
      {
         return uRocEpochCycle;
      }
      UInt_t GetLocalEpoch() const
      {
         return uLocalEpoch;
      }
      UInt_t GetLocalCycle() const
      {
         return uLocalEpochCycle;
      }

      Bool_t RocOrder( const TRocMessageExtended &messageToCompare )const;
      Bool_t LocalOrder( const TRocMessageExtended &messageToCompare) const;
      Double_t RocSpacing( const TRocMessageExtended &messageToCompare) const;
      Double_t LocalSpacing( const TRocMessageExtended &messageToCompare) const;

      void Print( unsigned kind = roc::msg_print_Human ) const;

      void assign(const TRocMessageExtended& src)
      {
         fxMessage = src.fxMessage;

         /* corrected adc value*/
         ffCorrectedADC = src.ffCorrectedADC;

         /* full time stamp without correction*/
         fuFulltime = src.fuFulltime;

         /* corrected time difference to trigger time of master ROC
          * float range should be sufficient here*/
         ffTriggerDeltaT = src.ffTriggerDeltaT;

         uRocEpoch = src.uRocEpoch;
         uRocEpochCycle = src.uRocEpochCycle;

         uLocalEpoch = src.uLocalEpoch;
         uLocalEpochCycle = src.uLocalEpochCycle;
      }


      TRocMessageExtended& operator=(const TRocMessageExtended& src)
      {
         assign(src);

         return *this;
      }

   protected:

      /* original roc message*/
      roc::Message fxMessage;

      /* corrected adc value*/
      float ffCorrectedADC;

      /* full time stamp without correction*/
      uint64_t fuFulltime;

      /* corrected time difference to trigger time of master ROC
       * float range should be sufficient here*/
      float ffTriggerDeltaT;

      UInt_t         uRocEpoch;
      UInt_t         uRocEpochCycle;

      ULong64_t      uLocalEpoch;
      UInt_t         uLocalEpochCycle;
};

class TRocData : public TGo4EventElement {
   public:
      TRocData();
      TRocData(const char* name, Short_t id=0);
      virtual ~TRocData();

      virtual void Clear(Option_t *t="");

      /* extended messages for each roc*/
      std::vector<TRocMessageExtended> fExtMessages;

      //std::vector<TGet4MessageFull>    vMessageEventBuffer;
      std::vector<TRocMessageExtended>    vMessageEventBuffer;
      /*************************************/
      
      /* last time of SYNC signals. obsolete now? */
      ULong64_t fLastSyncTm[MAX_SYNC];

      /* last time of trigger signal (defined by parameter)
       * can be sync or aux message, depending on TRocParameter::triggerSignal setup*/
      ULong64_t fLastTriggerTm;

      ClassDef(TRocData,1)
};



class TRocEvent : public TGo4CompositeEvent {
   public:
      TRocEvent();
      TRocEvent(const char* name, Short_t id=0);
      virtual ~TRocEvent();

      double GetEventTime() const { return fLastGlobalTriggerTm*1e-9; }

      /* Evaluate global corrected time stamp from trigger difference times
       * as stored for each extended message*/
      ULong64_t CalcGlobalTime(Double_t deltaTrigger);

      /* array for roc configuration*/
      static UInt_t    ConfigRocs[MAX_ROC];

      /* last time of trigger signal from configured "master" ROC
       * can be sync or aux message, depending on TRocParameter::triggerSignal setup
       * This is also time reference for global timestamp
       * This may be kept over several events, so we dont need a Clear method!*/
      ULong64_t fLastGlobalTriggerTm;

      ULong64_t fMbsEventNumber;

      ClassDef(TRocEvent,3)
};
#endif //TEVENT_H