CbmDeviceUnpackTofStar2018.h

Go to the documentation of this file.

 
#ifndef CBMDEVICEUNPACKTOFSTAR2018_H_
#define CBMDEVICEUNPACKTOFSTAR2018_H_
 
#include "FairMQDevice.h"
 
#include "rocMess_wGet4v1.h"
 
#include "MicrosliceDescriptor.hpp"
#include "Timeslice.hpp"
 
#include "Rtypes.h"
#include "TMessage.h"
 
#include <map>
#include <vector>
 
class CbmTofUnpackPar;
class CbmTbDaqBuffer;
class CbmHistManager;
class CbmTofDigiExp;
class TH1;
class TH2;
 
class CbmDeviceUnpackTofStar2018 : public FairMQDevice {
public:
  CbmDeviceUnpackTofStar2018();
  virtual ~CbmDeviceUnpackTofStar2018();
 
protected:
  virtual void InitTask();
  bool HandleData(FairMQMessagePtr&, int);
 
private:
  uint64_t fNumMessages;
 
  std::vector<std::string> fAllowedChannels = {"tofcomponent", "parameters"};
 
 
  size_t
    fuMsAcceptsPercent; 
  size_t
    fuOverlapMsNb; 
  UInt_t fuMinNbGdpb;
  UInt_t fuCurrNbGdpb;
 
  UInt_t fuNrOfGdpbs;            // Total number of GDPBs in the system
  UInt_t fuNrOfFebsPerGdpb;      // Number of FEBs per GDPB
  UInt_t fuNrOfGet4PerFeb;       // Number of GET4s per FEB
  UInt_t fuNrOfChannelsPerGet4;  // Number of channels in each GET4
 
  UInt_t fuNrOfChannelsPerFeet;  // Number of channels in each FEET
  UInt_t fuNrOfGet4;             // Total number of Get4 chips in the system
  UInt_t fuNrOfGet4PerGdpb;      // Number of GET4s per GDPB
  UInt_t fuNrOfChannelsPerGdpb;  // Number of channels per GDPB
 
  std::vector<int> fMsgCounter;
  std::map<UInt_t, UInt_t> fGdpbIdIndexMap;
 
  UInt_t fuGdpbId;  // Id (hex number) of the GDPB for current message
  UInt_t
    fuGdpbNr;  // running number (0 to fNrOfGdpbs) of the GDPB for current message
  UInt_t
    fuGet4Id;  // running number (0 to fNrOfGet4PerGdpb) of the Get4 chip of a unique GDPB for current message
  UInt_t
    fuGet4Nr;  // running number (0 to fNrOfGet4) of the Get4 chip in the system for current message
 
  //   CbmHistManager* fHM;  ///< Histogram manager
 
  std::vector<ULong64_t> fvulCurrentEpoch;  
  std::vector<Bool_t> fvbFirstEpochSeen;    
 
  Int_t fNofEpochs;              
  ULong64_t fulCurrentEpochTime; 
  Int_t fEquipmentId;
  Double_t fdMsIndex;
  Double_t fdTShiftRef;
 
  Bool_t fbEpochSuppModeOn;
  Bool_t fbGet4M24b;
  Bool_t fbGet4v20;
  Bool_t fbMergedEpochsOn;
 
  CbmTofDigiExp* fDigi;
 
  CbmTofUnpackPar* fUnpackPar;  
 
  // Variables used for histo filling
  Double_t fdRefTime;
  Double_t fdLastDigiTime;
  Double_t fdFirstDigiTimeDif;
  Double_t fdEvTime0;
  TH1* fhRawTDigEvT0;
  TH1* fhRawTDigRef0;
  TH1* fhRawTDigRef;
  TH1* fhRawTRefDig0;
  TH1* fhRawTRefDig1;
  TH1* fhRawDigiLastDigi;
  std::vector<TH2*> fhRawTotCh;
  std::vector<TH1*> fhChCount;
  std::vector<Bool_t> fvbChanThere;
  std::vector<TH2*> fhChanCoinc;
  Bool_t fbDetChanThere[64];
  TH2* fhDetChanCoinc;
 
  std::vector<std::vector<ngdpb::Message>> fvmEpSupprBuffer;
 
  CbmTbDaqBuffer* fBuffer;
 
 
  ULong64_t fulGdpbTsMsb;
  ULong64_t fulGdpbTsLsb;
  ULong64_t fulStarTsMsb;
  ULong64_t fulStarTsMid;
  ULong64_t fulGdpbTsFullLast;
  ULong64_t fulStarTsFullLast;
  UInt_t fuStarTokenLast;
  UInt_t fuStarDaqCmdLast;
  UInt_t fuStarTrigCmdLast;
 
  bool CheckTimeslice(const fles::Timeslice& ts);
  void PrintMicroSliceDescriptor(const fles::MicrosliceDescriptor& mdsc);
  bool IsChannelNameAllowed(std::string channelName);
 
  Bool_t InitContainers();
 
  Bool_t ReInitContainers();
  void CreateHistograms();
 
  void FillHitInfo(ngdpb::Message);
  void FillStarTrigInfo(ngdpb::Message);
  void FillEpochInfo(ngdpb::Message);
  void PrintSlcInfo(ngdpb::Message);
  void PrintSysInfo(ngdpb::Message);
  void PrintGenInfo(ngdpb::Message);
 
  Bool_t DoUnpack(const fles::Timeslice& ts, size_t component);
 
 
  inline Int_t GetArrayIndex(Int_t gdpbId, Int_t get4Id) {
    return gdpbId * fuNrOfGet4PerGdpb + get4Id;
  }
};
 
// special class to expose protected TMessage constructor
class CbmMQTMessage : public TMessage {
public:
  CbmMQTMessage(void* buf, Int_t len) : TMessage(buf, len) {
    ResetBit(kIsOwner);
  }
};
 
 
#endif /* CBMDEVICEUNPACKTOFSTAR2018_H_ */