#ifndef TMANUEVENT_HH
#define TMANUEVENT_HH

#include "TObject.h"
#include "TVector2.h"
#include "TVector3.h"
#include "TLorentzVector.h"
#include "TClonesArray.h"



/////////
// Header
/////////
class TManuHeader : public TObject
{
public:
  TManuHeader()  {}
  ~TManuHeader() {}
  
  Int_t    GetRunNumber()           const { return fRunNumber; }
  Int_t    GetEventNumber()         const { return fEventNumber; }
  Double_t GetInstLumi()            const { return fInstLumi; }
  TVector2 *GetBeamPosition()       const { return fBeamPosition; }
  TVector2 *GetBeamPositionSigma()  const { return fBeamPositionSigma; }
  Bool_t   GetTriggered()           const { return fTriggered; }
  Int_t    GetNClcEastHitsOver250() const { return fNClcEastHitsOver250; }
  Int_t    GetNClcWestHitsOver250() const { return fNClcWestHitsOver250; }

  void SetRunNumber(          Int_t    x)  { fRunNumber           = x; }
  void SetEventNumber(        Int_t    x)  { fEventNumber         = x; }
  void SetInstLumi(           Double_t x)  { fInstLumi            = x; }
  void SetBeamPosition(       TVector2 *x) { fBeamPosition        = x; }
  void SetBeamPositionSigma(  TVector2 *x) { fBeamPositionSigma   = x; }
  void SetTriggered(          Bool_t   x)  { fTriggered           = x; }
  void SetNClcEastHitsOver250(Int_t    x)  { fNClcEastHitsOver250 = x; }
  void SetNClcWestHitsOver250(Int_t    x)  { fNClcWestHitsOver250 = x; }

  void PrintHeader();
  
private:
  Int_t    fRunNumber;
  Int_t    fEventNumber;
  Double_t fInstLumi;
  TVector2 *fBeamPosition;
  TVector2 *fBeamPositionSigma;
  Bool_t   fTriggered;
  Int_t    fNClcEastHitsOver250;
  Int_t    fNClcWestHitsOver250;
  
  ClassDef(TManuHeader, 0)
};



/////////
// Vertex
/////////
class TManuVertex : public TObject
{
public:
  TManuVertex()  { fPosition = new TVector3(); fPositionSigma = new TVector3(); }
  ~TManuVertex() { delete fPosition;           delete fPositionSigma; }

  void     PrintVertex();

  Int_t    GetClass()          const { return fClass; }
  TVector3 *GetPosition()      const { return fPosition; }
  TVector3 *GetPositionSigma() const { return fPositionSigma; }

  void SetClass(        Int_t    x)  { fClass         = x; }
  void SetPosition(     TVector3 *x) { fPosition      = x; }
  void SetPositionSigma(TVector3 *x) { fPositionSigma = x; }

private:
  Int_t    fClass;
  TVector3 *fPosition;
  TVector3 *fPositionSigma;
  
  ClassDef(TManuVertex, 0)
};



////////
// Track
////////
class TManuTrack : public TObject
{
public:
  TManuTrack()  {}
  ~TManuTrack() {}

  void           PrintTrack();

  Int_t          GetAlgorithm()   const { return fAlgorithm; }
  Double_t       GetLam0()        const { return fLam0; }
  Double_t       GetC0()          const { return fC0; }
  Double_t       GetCharge()      const { return fCharge; }
  Double_t       GetD0()          const { return fD0; }
  Double_t       GetD0Corrected() const { return fD0Corrected; }
  Double_t       GetZ0()          const { return fZ0; }
  Double_t       GetPhi0()        const { return fPhi0; }
  Double_t       GetChi2()        const { return fChi2; }
  Double_t       GetChi2SVX()     const { return fChi2SVX; }
  Double_t       GetChi2COT()     const { return fChi2COT; }
  Double_t       GetSVXRPhiHits() const { return fSVXRPhiHits; }
  Double_t       GetSVXZHits()    const { return fSVXZHits; }
  Double_t       GetSVXSASHits()  const { return fSVXSASHits; }
  Double_t       GetCOTAxHits()   const { return fCOTAxHits; }
  Double_t       GetCOTStHits()   const { return fCOTStHits; }
  Double_t       GetCOTAxSegs5()  const { return fCOTAxSegs5; }
  Double_t       GetCOTStSegs5()  const { return fCOTStSegs5; }
  TLorentzVector *GetMomentum()   const { return fMomentum; }
  Double_t       GetPt()          const { return fMomentum->Pt(); }
  Double_t       GetEta()         const { return fMomentum->Eta(); }

  void SetAlgorithm(  Int_t          x)  { fAlgorithm   = x; }
  void SetLam0(       Double_t       x)  { fLam0        = x; }
  void SetC0(         Double_t       x)  { fC0          = x; }
  void SetCharge(     Double_t       x)  { fCharge      = x; }
  void SetD0(         Double_t       x)  { fD0          = x; }
  void SetD0Corrected(Double_t       x)  { fD0Corrected = x; }
  void SetZ0(         Double_t       x)  { fZ0          = x; }
  void SetPhi0(       Double_t       x)  { fPhi0        = x; }
  void SetChi2(       Double_t       x)  { fChi2        = x; }
  void SetChi2SVX(    Double_t       x)  { fChi2SVX     = x; }
  void SetChi2COT(    Double_t       x)  { fChi2COT     = x; }
  void SetSVXRPhiHits(Double_t       x)  { fSVXRPhiHits = x; }
  void SetSVXZHits(   Double_t       x)  { fSVXZHits    = x; }
  void SetSVXSASHits( Double_t       x)  { fSVXSASHits  = x; }
  void SetCOTAxHits(  Double_t       x)  { fCOTAxHits   = x; }
  void SetCOTStHits(  Double_t       x)  { fCOTStHits   = x; }
  void SetCOTAxSegs5( Double_t       x)  { fCOTAxSegs5  = x; }
  void SetCOTStSegs5( Double_t       x)  { fCOTStSegs5  = x; }
  void SetMomentum(   TLorentzVector *x) { fMomentum    = x; }

private:
  Int_t          fAlgorithm;
  Double_t       fLam0;
  Double_t       fC0;
  Double_t       fCharge;
  Double_t       fD0;
  Double_t       fD0Corrected;
  Double_t       fZ0;
  Double_t       fPhi0;
  Double_t       fChi2;
  Double_t       fChi2SVX;
  Double_t       fChi2COT;
  Double_t       fSVXRPhiHits;
  Double_t       fSVXZHits;
  Double_t       fSVXSASHits;
  Double_t       fCOTAxHits;
  Double_t       fCOTStHits;
  Double_t       fCOTAxSegs5;
  Double_t       fCOTStSegs5;
  TLorentzVector *fMomentum;
  
  ClassDef(TManuTrack, 0)
};



////////
// Event
////////
class TManuEvent : public TObject
{
public:
  TManuEvent();
  ~TManuEvent();

  TManuHeader *GetHeader()                { return fHeader; }
  Int_t       GetNVertices()        const { return fNVertices; }
  Int_t       GetNTracks()          const { return fNTracks; }

  void        PrintHeader();
//   void        PrintTrack(Int_t i);
//   void        PrinVertex(Int_t i);
  
  TManuHeader *AddHeader();
  TManuVertex *AddVertex();
  TManuTrack  *AddTrack();
  
//    void          SetMatrix(UChar_t x, UChar_t y, Double32_t what) { if (x<3&&y<3) fMatrix[x][y]=what;}
//    Double32_t    GetMatrix(UChar_t x, UChar_t y) { return (x<4&&y<4)?fMatrix[x][y]:0; }



private:
  static TClonesArray *fgVertices;
  static TClonesArray *fgTracks;

  TManuHeader  *fHeader;

  Int_t        fNTracks;
  TClonesArray *fTracks;            //->array with all tracks

  Int_t        fNVertices;
  TClonesArray *fVertices;            //->array with all vertices

//    Double32_t     fMatrix[4][4];

   ClassDef(TManuEvent, 0)
};

#endif