/data3/calcul/jacquem/working_dir/Micromegas/micromegasFrameWork/include/root/MTEvent.hh

Go to the documentation of this file.

#ifndef ROOT_MTEvent
#define ROOT_MTEvent

#include "TObject.h"
#include "TClonesArray.h"
#include "TRefArray.h"
#include "TRef.h"
#include "TH1.h"
#include "TMath.h"
#include <vector>
#include <map>

#include "root/MTChipSoftId.hh"


class Event;
class ChannelHit ;
class MTChannel ;
class MTTrack ;
////////////////////////////////////////////////////////////////////////////////////////
///     CLASS EVENT (containing Header and MTChannel)
/// - Hardroc + Dirac: 1 evenement == 1 lecture de tous les chips d'une Dif 
/// - Gassiplex : 1 evenement == 1 Trigger PM == 1 ecriture Gassiplex
///////////////////////////////////////////////////////////////////////////////////////
class MTEvent : public TObject {

private:
   bool fSquareEvt; // default false
   bool fBorderEvt; // default false
   bool fChipEvt; // default false
   bool fTimeInfo; // default false:  ->true si l'info en temps est vrai, c.a.d. si la dernièrer lecture était il y a moins de 3.35 s. sinon false

   UInt_t                   fEventId;
   Double32_t               fTemperature;
   std::map<UInt_t,Float_t> fTemperatureAsu1;  // Key is difId
   std::map<UInt_t,Float_t> fTemperatureAsu2;  // Key is difId
   std::map<UInt_t,Float_t> fTemperatureDif;  // Key is difId
   Double32_t               fPressure;
   ULong64_t                  fDifSynchro;
   ULong64_t                fTimestamp;  // millisecond fromn 1 janv 1970
   UInt_t                   fGlobalTriggerCounter; // increment at each trigger
   UInt_t                   fDifTriggerCounter;    // increment on trigger only if dif store data

   std::map<UInt_t, std::map<UInt_t, UInt_t>* >fNbHitPerAbsTime;   // key is boardId, key is bcId_hit, value is nbHi
   // Absolutime is compute as following : bcid_abs - (bcid_dif - bcid_hit)

   Int_t          fNchannel;          //Number of channels hit for this event
   TClonesArray  *fChannels;          //->array with all channels
   // channels are sorted before being inserted into TClonesArray.
   // Thus fChannels[0] will contain highest channel response and fChannels[fChannels.GetSize()-1]
   // will contain lowest channel responce

   std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >fMeshVoltage;
   std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >* >fDriftVoltage;

   std::vector<UInt_t> fDtCandidate;

   MTTrack* fTrack;





   static TClonesArray *fgChannels;


   bool fCrcIsCorrect;
   UInt_t fValid;

public:
   MTEvent();
   virtual ~MTEvent();
   MTEvent&  operator=( const  Event& rhs) ;
   MTEvent&  operator=( const  MTEvent& rhs);

   //MTEvent&      operator=( const  MTEvent& rhs) ;
   void          Build(UInt_t evtId,ULong64_t difSynchro, Double32_t  temperature, Double32_t  pressure , ULong64_t  timestamp );
   void          SetTrack(MTTrack* aTrack) { fTrack = aTrack;};
   MTTrack*      GetTrack(void){  return fTrack;} ;

   bool          GetSquareEvt(void) { return fSquareEvt; } ;
   void          SetSquareEvt(bool value){ fSquareEvt = value; } ;
   bool          GetBorderEvt(void) { return fBorderEvt; } ;
   void          SetBorderEvt(bool value){ fBorderEvt = value; } ;
   bool          GetChipEvt(void) { return fChipEvt; } ;
   void          SetChipEvt(bool value){ fChipEvt = value; } ;
   bool          GetTimeInfo(void) { return fTimeInfo; } ;
   void          SetTimeInfo(bool value){ fTimeInfo = value; } ;

   std::vector<UInt_t>& GetDtCandidate() { return fDtCandidate; }

   void          Clear(Option_t *option ="");
   static void   Reset(Option_t *option ="");
   void          SortChannel() { fChannels->Sort(); };
   void SetGlobalTriggerCounter(UInt_t value) { fGlobalTriggerCounter = value; };
   void SetDifTriggerCounter(UInt_t value) { fDifTriggerCounter = value; };
   UInt_t GetGlobalTriggerCounter(void) const { return fGlobalTriggerCounter; };
   UInt_t GetDifTriggerCounter(void) const { return fDifTriggerCounter; };

   void   AddHitForAbsTime(UInt_t boardId,UInt_t abs_time, UInt_t increment); 
   UInt_t  GetNbHitPerAbsTime(UInt_t boardId,UInt_t abs_time) const ;
   std::map< UInt_t, std::map<UInt_t, UInt_t>* > & GetNbHitPerAbsTime(){ return fNbHitPerAbsTime; };

   bool GetCrcIsCorrect(void) const { return fCrcIsCorrect;} ;
   UInt_t  GetValidFlag(void) const { return fValid;} ;
   void SetValidFlag(UInt_t  value) { fValid = fValid + value; };
   bool IsValid(void);

   void SetCrcIsCorrect(bool value) { fCrcIsCorrect = value; };
  bool IsSquare(UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb); //input : nbPad = threshold where we consider an event "Square"; chb = chamber ID; outputs: asu = the asu where the event is square; abs_time = the abs_time when the event is square
  bool IsBorder(UInt_t nbPad, UInt_t &asu, UInt_t &abs_time, UInt_t chb); //input : nbPad = threshold where we consider an event "Border"; chb = chamber ID; outputs: asu = the asu where the event is border; abs_time = the abs_time when the event is border
  bool IsChip(UInt_t nbPad, UInt_t &chip, UInt_t &abs_time, UInt_t chb); //input : nbPad = threshold where we consider an event "Chip"; chb = chamber ID; outputs: chip = the chip where the event is chip; abs_time = the abs_time when the event is chip

   void          SetDifSynchro(ULong64_t t) { fDifSynchro = t; };
   void          SetTemperature(Double32_t t) { fTemperature = t; };
   void          SetPressure(Double32_t t) { fPressure = t; };
   void          SetTimestamp(ULong64_t t) { fTimestamp = t; };
   void          SetEventId(UInt_t aId) { fEventId = aId; } ;
   MTChannel*    AddChannel(const ChannelHit& hit, UInt_t order);
   MTChannel*    AddChannel(MTChannel* aChannel) ;


   UInt_t        GetEventId() const { return fEventId; };
   UInt_t        GetId() const { return GetEventId(); };
   ULong64_t       GetDifSynchro() const { return fDifSynchro; } ;
   UInt_t        GetNchannel() const { return fNchannel; };
   void          SetNchannel(Int_t n) ;

   UInt_t        GetNchannel(UInt_t chamberId) const ;
   Double32_t    GetTemperature() const { return fTemperature; };
   ULong64_t     GetTimestamp() const {return fTimestamp;};           
   Double32_t    GetPressure() const { return fPressure; };
   TClonesArray* GetChannels() const { return fChannels; };
   MTChannel*    GetChannelByOrder(UInt_t order,UInt_t chamberId) const;

   std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >*  >GetMeshVoltage() const { return fMeshVoltage; };
   std::map<UInt_t, std::map<UInt_t, std::map<UInt_t, Float_t>* >*  >GetDriftVoltage() const { return fDriftVoltage; };

   Float_t GetMeshVoltage(const Int_t chamberId,Int_t difId, Int_t boardId) const ;
   Float_t GetDriftVoltage(const Int_t chamberId,Int_t difId, Int_t boardId) const ;

   void    SetMeshVoltage(const Int_t chamberId, Int_t difId, Int_t boardId,const Float_t aValue) ;
   void    SetDriftVoltage(const Int_t chamberId, Int_t difId, Int_t boardId,const Float_t aValue) ;

   void SetTemperature(UInt_t difId,Float_t asu1, Float_t asu2, Float_t dif);
   void SetTemperatureAsu1(UInt_t difId,Float_t asu1);
   void SetTemperatureAsu2(UInt_t difId,Float_t asu2);
   void SetTemperatureDif(UInt_t difId, Float_t dif);

   Float_t GetTemperatureAsu1( UInt_t difId ) const ;
   Float_t GetTemperatureAsu2( UInt_t difId ) const ;
   Float_t GetTemperatureDif( UInt_t difId ) const ;

   std::map<UInt_t,Float_t>GetTemperatureAsu1(void) { return fTemperatureAsu1; } ;
   std::map<UInt_t,Float_t>GetTemperatureAsu2(void) { return fTemperatureAsu2; } ;
   std::map<UInt_t,Float_t>GetTemperatureDif(void)  { return fTemperatureDif; } ;



private:

   ClassDef(MTEvent, 30)  //MTEvent structure
};


#endif

---