AgataEventContainer.h

Go to the documentation of this file.

#ifndef Gw_AgataEventContainer
#define Gw_AgataEventContainer

#ifndef ROOT_TClonesArray
#include "TClonesArray.h"
#endif

#ifndef ROOT_TString
#include "TString.h"
#endif

#include "GwLogMessage.h"

#ifndef Gw_BaseEventContainer
#include "BaseEventContainer.h"
#endif


namespace Gw {
class TrackHit;
class StdHit;
class AgataEventContainer : public BaseEventContainer
{

private :
  
  static const TString fgkTypeNameExt[];  // extention name of the different types
  static       TString fgTypeName[];      // name of the different types
  static const Int_t   fgkMaxNofTypeName; // Max number of the different types
  
private:
  
  TClonesArray* fCurrentTrackList[4];   // current track list for each type of particles
  TClonesArray* fCurrentHitList[4];     // current hit list for each type of particles

  TClonesArray* fTrackList;             // track list to be read
  TClonesArray* fHitList;               // hit list to be read 
  
  Int_t         fNofBracnhes;           // number of branches
  
private:
  
  TString GetTrackBranchName(Option_t* type) const;
  TString GetHitBranchName(Option_t* type) const;

public:

  static const Char_t* GetTypeName(Int_t idx) { if (idx < fgkMaxNofTypeName) return fgTypeName[idx]; else return ""; }
  
public:
  AgataEventContainer();
  virtual ~AgataEventContainer();
  
  TrackHit* NewTrackHit(Option_t* type = "Agata");

  StdHit*  NewHit(Option_t* type = "Agata");
  
  TClonesArray* GetTrackList(Int_t ievent, Option_t* type = "Agata", Bool_t warn = true);
  
  TClonesArray* GetHitList(Int_t ievent, Option_t* type = "Agata", Bool_t warn = true);
  
  void ClearEvents();
  
  void FillHits(Option_t* type = "Agata");
  void FillTracks(Option_t* type = "Agata");
  
  const Char_t* RegisterBranch(Option_t* type = "");
  
  Int_t GetNofBranches() const { return fNofBracnhes; }

  Int_t GetIndex(Option_t* type) const;

  ClassDef(AgataEventContainer,0)  // event container
};
  
  
class StdHit : public TObject
{
private:
  Float_t fX; // X position 
  Float_t fY; // Y position
  Float_t fZ; // Z position
  
  Float_t fE; // Energy
  Float_t fT; // Time   

  Float_t fDX; // Error on X  
  Float_t fDY; // Error on Y    
  Float_t fDZ; // Error on Z    
  
  Float_t fDE; // Error on E               
  Float_t fDT; // Error on T 
      
public:
  StdHit(){fX=fY=fZ=fE=fT=fDX=fDY=fDZ=fDE=fDT=0.;}
  virtual ~StdHit() {;}
  
  // reset
  virtual void Reset() { fX = fY = fZ = fE = fT = fDX = fDY = fDZ = fDE  = fDT = 0.; }

  virtual void SetX(Float_t x) { fX = x; }
  virtual void SetY(Float_t y) { fY = y; }     
  virtual void SetZ(Float_t z) { fZ = z; }
  virtual void SetE(Float_t e) { fE = e; } 
  virtual void SetT(Float_t t) { fT = t; }
  virtual void SetXYZ(Float_t x, Float_t y, Float_t z) { fX=x; fY=y; fZ=z; }    

  virtual void SetDX(Float_t dx) { fDX = dx; }
  virtual void SetDY(Float_t dy) { fDY = dy; }     
  virtual void SetDZ(Float_t dz) { fDZ = dz; }
  virtual void SetDXYZ(Float_t dx, Float_t dy, Float_t dz) { fDX=dx; fDY=dy; fDZ=dz; }    
  
  virtual void SetDE(Float_t de) { fDE = de; } 
  virtual void SetDT(Float_t dt) { fDT = dt; }   
    
  virtual Float_t GetX() const { return fX; } 
  virtual Float_t GetY() const { return fY; }       
  virtual Float_t GetZ() const { return fZ; }    
  virtual Float_t GetE() const { return fE; }  
  virtual Float_t GetT() const { return fT; }   
  
  virtual Float_t GetDX() const { return fDX; } 
  virtual Float_t GetDY() const { return fDY; }       
  virtual Float_t GetDZ() const { return fDZ; }    
  virtual void GetDXYZ(Float_t &dx, Float_t &dy, Float_t &dz) const { dx=fDX; dy=fDY; dz = fDZ; } 
  
  virtual Float_t GetDE() const { return fDE; }            
  virtual Float_t GetDT() const { return fDT; }
    
  ClassDef(StdHit,1)  // event container

};
  
class TrackHit : public TObject
{
  private:
    
    StdHit fHit;       // contains first impact in detector and total energy deposited
    TClonesArray* fTrackList; // contains all hits of the traces
    
  public:
    TrackHit();
    virtual ~TrackHit();
    
    Int_t GetNbHits() const;
    
    StdHit* NewHit();
    
    StdHit* GetHit(Int_t i = 0) const;
  
        void Reset() {fTrackList->Delete(); fHit.Reset();}
  
    virtual void SetX(Float_t x) { fHit.SetX(x); }
    virtual void SetY(Float_t y) { fHit.SetY(y); }     
    virtual void SetZ(Float_t z) { fHit.SetZ(z); }
    virtual void SetE(Float_t e) { fHit.SetE(e); } 
    virtual void SetT(Float_t t) { fHit.SetT(t); }
    virtual void SetXYZ(Float_t x, Float_t y, Float_t z) { fHit.SetXYZ(x, y, z); }    
  
    virtual void SetDX(Float_t dx) { fHit.SetDX(dx); }
    virtual void SetDY(Float_t dy) { fHit.SetDY(dy); }     
    virtual void SetDZ(Float_t dz) { fHit.SetDZ(dz); }
    virtual void SetDXYZ(Float_t dx, Float_t dy, Float_t dz) { fHit.SetDXYZ(dx, dy, dz); }    
    
    virtual void SetDE(Float_t de) { fHit.SetDE(de); } 
    virtual void SetDT(Float_t dt) { fHit.SetDT(dt); }      
    
    virtual Float_t GetX() const { return fHit.GetX(); } 
    virtual Float_t GetY() const { return fHit.GetY(); }       
    virtual Float_t GetZ() const { return fHit.GetZ(); }    
    virtual Float_t GetE() const { return fHit.GetE(); }  
    virtual Float_t GetT() const { return fHit.GetT(); }   
    
    virtual Float_t GetDX() const { return fHit.GetDX(); } 
    virtual Float_t GetDY() const { return fHit.GetDY(); }       
    virtual Float_t GetDZ() const { return fHit.GetDZ(); }    
    virtual void GetDXYZ(Float_t &dx, Float_t &dy, Float_t &dz) const { fHit.GetDXYZ(dx, dy, dz); } 
    
    virtual Float_t GetDE() const { return fHit.GetDE(); }            
    virtual Float_t GetDT() const { return fHit.GetDT(); }
  
        ClassDef(TrackHit,1)  // event container

};
  

} // end namespace

#endif