HarpoRecoEvent.h

Go to the documentation of this file.

#ifndef HARPORECOEVENT_H
#define HARPORECOEVENT_H


//
// HarpoReconstructionWriter
//
// save the informations of cluster and tracking in a file.root
//

#include "TObject.h"
#include "TClonesArray.h"
#include "TVector3.h"
//#include "TGraph.h"
//#include "TArrayD.h"

#define MAXTRPERCL 20
#define NCLUSTERMAX 6000

#define NCLUSTERTYPES 3
#define CCLUSTER 0
#define TCLUSTER 1
#define BLOCCLUSTER 2
#define HOUGH 1
#define KALMAN 2

class HarpoRecoClusters : public TObject {
 public:
  
  HarpoRecoClusters();
  HarpoRecoClusters(Int_t Type, Double_t Q, Double_t Qmax, Double_t Mean, Int_t Index, Double_t Sig,Int_t iFirst,Int_t Width,Int_t IdClusterTrack,Int_t plane,Int_t quality = 0);
  HarpoRecoClusters(const HarpoRecoClusters &clu);
  virtual ~HarpoRecoClusters();
  
  Int_t GetType(){return fType;}
  Int_t GetQ(){return fQ;}
  Int_t GetQmax(){return fQmax;}
  Double_t GetMean(){return fMean;}
  Int_t GetIndex(){return fIndex;}
  Double_t GetSig(){return fSig;}
  Int_t GetWidth(){return fWidth;}
  Int_t GetIfirst(){return fIfirst;}
  Int_t GetPlane(){return fPlane;}
  Int_t GetIdClusterTrack(){return fIdClusterTrack[0];}
  Int_t GetIdClusterTrack(Int_t i){
    if(i>=0 && i<MAXTRPERCL) return fIdClusterTrack[i];
    return -1;
  }
  Double_t GetX(){return fX;}
  Double_t GetZ(){return fZ;}
  Double_t GetXfit(Int_t i = 0){return fXfit[i];}
  Double_t GetZfit(Int_t i = 0){return fZfit[i];}
  Int_t GetNtr() {return fNtr;}  
  Int_t GetQuality(){return fQuality;}

  void SetQuality(Int_t val){fQuality = val;}
  void SetType(Int_t val){fType = val;}
  void SetMean(Double_t val){fMean = val;}
  void SetIndex(Int_t val){fIndex = val;}
  void SetSig(Double_t val){fSig = val;}
  void SetWidth(Int_t val){fWidth = val;}
  void SetIfirst(Int_t val){fIfirst = val;}
  void SetQ(Int_t val){fQ = val;}
  void SetQmax(Int_t val){fQmax = val;}
  void SetPlane(Int_t val){fPlane = val;}
  void SetIdClusterTrack(Int_t val){fIdClusterTrack[0] = val;}
  void SetX(Double_t val){ fX = val;}
  void SetZ(Double_t val){ fZ = val;}
  void SetXfit(Int_t i, Double_t val){ fXfit[i] = val;}
  void SetZfit(Int_t i, Double_t val){ fZfit[i] = val;}
  void AddIdClusterTrack(Int_t val);
  void RemoveIdClusterTrack(Int_t val);
  void RemoveAllClusterTrack(){
    for(Int_t i = 0; i<MAXTRPERCL; i++)
      fIdClusterTrack[i] = -1;
    fNtr = 0;
  }
  Bool_t CheckIdClusterTrack(Int_t val){
    for(Int_t i = 0; i<MAXTRPERCL; i++)
      if(fIdClusterTrack[i]==val) return kTRUE;
    return kFALSE;
  }
    

 private:
  Int_t    fType;
  Double_t fQ;  
  Double_t fQmax;                         
  Double_t fMean;       
  Int_t    fIndex;                    
  Double_t fX;  
  Double_t fZ;  
  Double_t fSig;          
  Int_t    fWidth;                    
  Int_t    fIfirst;                    
  Int_t    fQuality;             
  Int_t    fNtr;                         
  Int_t    fPlane;              
  Int_t    fIdClusterTrack[MAXTRPERCL];
  Double_t fXfit[MAXTRPERCL];
  Double_t fZfit[MAXTRPERCL];
  
  ClassDef(HarpoRecoClusters,1);
};



class HarpoRecoTracks : public TObject {
 public:
  
  HarpoRecoTracks();
  HarpoRecoTracks(Int_t Ntrack,Int_t QtTrack,Double_t AngleTrack,Double_t x0, Int_t TypeTrack,Int_t IdTrackMatching,Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart, Double_t xEnd, Double_t zEnd);
  HarpoRecoTracks(const HarpoRecoTracks &tra);
  virtual ~HarpoRecoTracks();
  
  Int_t GetNtrack(){return fNtrack;}
  Int_t GetQtTrack(){return fQtTrack;}
  Int_t GetPlane(){return fPlane;}
  Double_t GetAngleTrack(){return fAngleTrack;}
  Double_t GetX0(){return fX0;}
  Int_t GetTypeTrack(){return fTypeTrack;}
  Int_t GetIdTrackMatching(){return fIdTrackMatching;}
  Int_t GetNclusterTrack(){return fNclusterTrack;}
  Double_t GetXstart(){return fXstart;}
  Double_t GetZstart(){return fZstart;}
  Double_t GetXend(){return fXend;}
  Double_t GetZend(){return fZend;}

  void SetNtrack(Int_t val){fNtrack = val;}
  void SetQtTrack(Int_t val){fQtTrack = val;}
  void SetPlane(Int_t val){fPlane = val;}
  void SetAngleTrack(Int_t val){fAngleTrack = val;}
  void SetX0(Double_t val){fX0 = val;}
  void SetTypeTrack(Int_t val){fTypeTrack = val;}
  void SetIdTrackMatching(Int_t val){fIdTrackMatching = val;}
  void SetNclusterTrack(Int_t val){fNclusterTrack = val;}
  void SetXstart(Double_t val){fXstart = val;}
  void SetZstart(Double_t val){fZstart = val;}
  void SetXend(Double_t val){fXend = val;}
  void SetZend(Double_t val){fZend = val;}

 private:
 
  Int_t fNtrack;
  Int_t fQtTrack;
  Double_t fAngleTrack;
  Double_t fX0;
  Int_t fTypeTrack;
  Int_t fPlane;
  Int_t fIdTrackMatching;
  Int_t fNclusterTrack; 
  Double_t fXstart;      
  Double_t fZstart;
  Double_t fXend;           
  Double_t fZend;
  
  ClassDef(HarpoRecoTracks,1);
};


class HarpoRecoHoughTracks : public HarpoRecoTracks {
 public:
  
  HarpoRecoHoughTracks();
  HarpoRecoHoughTracks(Int_t Ntrack, Double_t Mtheta, Double_t Mrho,Double_t Sigtheta,Double_t Sigrho,Int_t QtTrack,Double_t AngleTrack,Double_t x0, Int_t TypeTrack,Int_t IdTrackMatching,Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart, Double_t xEnd, Double_t zEnd);
  HarpoRecoHoughTracks(const HarpoRecoHoughTracks &tra);
  virtual ~HarpoRecoHoughTracks();
  
  Double_t GetMtheta(){return fMtheta;}
  Double_t GetMrho(){return fMrho;}
  Double_t GetSigtheta(){return fSigtheta;}
  Double_t GetSigrho(){return fSigrho;}

  void SetMtheta(Double_t val){fMtheta = val;}
  void SetMrho(Double_t val){fMrho = val;}
  void SetSigtheta(Double_t val){fSigtheta = val;}
  void SetSigrho(Double_t val){fSigrho = val;}
  
 private:
  Double_t fMtheta;
  Double_t fMrho;
  Double_t fSigtheta;
  Double_t fSigrho;

  ClassDef(HarpoRecoHoughTracks,1);
};



class HarpoRecoKalmanTracks : public HarpoRecoTracks {
 public:
  
  HarpoRecoKalmanTracks();
  HarpoRecoKalmanTracks(Int_t Ntrack, Int_t QtTrack, Double_t AngleTrack,Double_t x0,Double_t chi2, Int_t TypeTrack, Int_t IdTrackMatching, Int_t NclusterTrack,Int_t plane, Double_t xStart, Double_t zStart, Double_t pxStart, Double_t pzStart, Double_t xEnd, Double_t zEnd, Double_t pxEnd, Double_t pzEnd);
  HarpoRecoKalmanTracks(const HarpoRecoKalmanTracks &tra);
  virtual ~HarpoRecoKalmanTracks();
  
  Double_t GetPxStart(){return fPxStart;}
  Double_t GetPzStart(){return fPzStart;}
  Double_t GetPxEnd()  {return fPxEnd;}
  Double_t GetPzEnd()  {return fPzEnd;}
  //  TGraph*  GetGraph()  {return fGraph;}
  Double_t GetChi2(){return fChi2;}

  void SetPxStart(Double_t val){fPxStart = val;}
  void SetPzStart(Double_t val){fPzStart = val;}
  void SetPxEnd(Double_t val)  {fPxEnd = val;}
  void SetPzEnd(Double_t val)  {fPzEnd = val;}
  //  void SetGraph(TGraph* g)     {fGraph = g;}
  void SetChi2(Double_t val){fChi2 = val;}

 private:
 
  Double_t fPxStart;      
  Double_t fPzStart;  
  Double_t fPxEnd;      
  Double_t fPzEnd;
  Double_t fChi2;

  //  TGraph*  fGraph;          // filtered points

  ClassDef(HarpoRecoKalmanTracks,1);
};

class HarpoRecoVertex : public TObject {
 public:
  
  HarpoRecoVertex();
  HarpoRecoVertex(Int_t plane, Double_t z, Double_t x, Double_t pz, Double_t px, Double_t theta, Double_t chi2, Int_t tr1, Int_t tr2);
  HarpoRecoVertex(const HarpoRecoVertex &vec);
  virtual ~HarpoRecoVertex();
  
  void SetPlane(Int_t val){fPlane = val;}
  void SetNvertex(Int_t val){fNvertex = val;}
  void SetTr1Vertex(Int_t val){fTr1Vertex = val;}
  void SetTr2Vertex(Int_t val){fTr2Vertex = val;}
  void SetXvertex(Double_t val){fXvertex = val;}
  void SetZvertex(Double_t val){fZvertex = val;}
  void SetPxVertex(Double_t val){fPxVertex = val;}
  void SetPzVertex(Double_t val){fPzVertex = val;}
  void SetThetaVertex(Double_t val){fThetaVertex = val;}
  void SetChi2Vertex(Double_t val){fChi2Vertex = val;}
  
 
  Int_t GetPlane(){return fPlane;}
  Int_t GetNvertex(){return fNvertex;}
  Int_t GetTr1Vertex1(){return fTr1Vertex;}
  Int_t GetTr2Vertex2(){return fTr2Vertex;}
  Double_t GetXvertex(){return fXvertex;}
  Double_t GetZvertex(){return fZvertex;}
  Double_t GetPxVertex(){return fPxVertex;}
  Double_t GetPzVertex(){return fPzVertex;}
  Double_t GetThetaVertex(){return fThetaVertex;}
  Double_t GetChi2Vertex(){return fChi2Vertex;}

 private:

  Int_t fNvertex;
  Int_t fPlane;
  Int_t fTr1Vertex;
  Int_t fTr2Vertex;
  Double_t fXvertex;
  Double_t fZvertex;
  Double_t fPxVertex;
  Double_t fPzVertex;
  Double_t fThetaVertex;
  Double_t fChi2Vertex;

  
  ClassDef(HarpoRecoVertex,1);
};



class HarpoRecoVertex3D : public TObject {
 public:
  
  HarpoRecoVertex3D();
  HarpoRecoVertex3D(Double_t x, Double_t y, Double_t z, Double_t px1, Double_t py1, Double_t pz1, Double_t px2, Double_t py2, Double_t pz2, Int_t vX, Int_t vY, Double_t chi2);
  HarpoRecoVertex3D(const HarpoRecoVertex3D &vec);
  virtual ~HarpoRecoVertex3D();
  
  void SetIdVertex3D(Int_t val){fIdVertex3D = val;}
  void SetVertexX(Int_t val){fVertexX = val;}
  void SetVertexY(Int_t val){fVertexY = val;}
  void SetXvertex3D(Double_t val){fXvertex3D = val;}
  void SetYvertex3D(Double_t val){fYvertex3D = val;}
  void SetZvertex3D(Double_t val){fZvertex3D = val;}
  void SetPx1Vertex3D(Double_t val){fPx1Vertex3D = val;}
  void SetPy1Vertex3D(Double_t val){fPy1Vertex3D = val;}
  void SetPz1Vertex3D(Double_t val){fPz1Vertex3D = val;}
  void SetPx2Vertex3D(Double_t val){fPx2Vertex3D = val;}
  void SetPy2Vertex3D(Double_t val){fPy2Vertex3D = val;}
  void SetPz2Vertex3D(Double_t val){fPz2Vertex3D = val;}
  void SetChi2Vertex3D(Double_t val){fChi2Vertex3D = val;}


  Int_t GetIdVertex3D(){return fIdVertex3D;}
  Int_t GetVertexX(){return fVertexX;}
  Int_t GetVertexY(){return fVertexY;}
  Double_t GetXvertex3D(){return fXvertex3D;}
  Double_t GetYvertex3D(){return fYvertex3D;}
  Double_t GetZvertex3D(){return fZvertex3D;}
  Double_t GetPx1Vertex3D(){return fPx1Vertex3D;}
  Double_t GetPy1Vertex3D(){return fPy1Vertex3D;}
  Double_t GetPz1Vertex3D(){return fPz1Vertex3D;}
  Double_t GetPx2Vertex3D(){return fPx2Vertex3D;}
  Double_t GetPy2Vertex3D(){return fPy2Vertex3D;}
  Double_t GetPz2Vertex3D(){return fPz2Vertex3D;}
  Double_t GetChi2Vertex3D(){return fChi2Vertex3D;}
  TVector3 GetP1Vertex3D(){return TVector3(fPx1Vertex3D,fPy1Vertex3D,fPz1Vertex3D);}
  TVector3 GetP2Vertex3D(){return TVector3(fPx2Vertex3D,fPy2Vertex3D,fPz2Vertex3D);}

  Double_t GetOmega();
  Double_t GetOpenAngle();
  Double_t GetPxVertex3D();
  Double_t GetPyVertex3D();
  Double_t GetPzVertex3D();

 private:

  Int_t fIdVertex3D;
  Int_t fVertexX;
  Int_t fVertexY;
  Double_t fXvertex3D;
  Double_t fYvertex3D;
  Double_t fZvertex3D;
  Double_t fPx1Vertex3D;
  Double_t fPy1Vertex3D;
  Double_t fPz1Vertex3D;
  Double_t fPx2Vertex3D;
  Double_t fPy2Vertex3D;
  Double_t fPz2Vertex3D;
  Double_t fChi2Vertex3D;

  
  ClassDef(HarpoRecoVertex3D,1);
};


class HarpoRecoMatching : public TObject {
 public:
  
  HarpoRecoMatching();
  //  HarpoRecoMatching(Int_t ngoodmatch, Int_t iMatchTrX, Int_t iMatchTrY, Int_t run);
  //  HarpoRecoMatching(Int_t ngoodmatch, Int_t iMatchTrX, Int_t iMatchTrY,Double_t chi2);
  HarpoRecoMatching(Int_t ngoodmatch, Int_t iMatchTrX, Int_t iMatchTrX2, Int_t iMatchTrY, Int_t iMatchTrY2,Double_t chi2);
  HarpoRecoMatching(const HarpoRecoMatching &mat);
  virtual ~HarpoRecoMatching();
  
  Int_t Getngoodmatch(){return fngoodmatch;}
  Int_t GetiMatchTrX(){return fiMatchTrX;}
  Int_t GetiMatchTrY(){return fiMatchTrY;}
  Int_t GetiMatchTrX2(){return fiMatchTrX2;}
  Int_t GetiMatchTrY2(){return fiMatchTrY2;}
  Int_t GetChi2Matching(){return fChi2Matching;}
  //  Int_t GetRun(){return fRun;}
  
  void Setngoodmatch(Int_t val){fngoodmatch = val;}
  void SetiMatchTrX(Int_t val){fiMatchTrX = val;}
  void SetiMatchTrY(Int_t val){fiMatchTrY = val;}
  void SetiMatchTrX2(Int_t val){fiMatchTrX2 = val;}
  void SetiMatchTrY2(Int_t val){fiMatchTrY2 = val;}
  void SetChi2Matching(Double_t val){fChi2Matching = val;}
  //  void SetRun(Int_t val){fRun = val;}
  
 private:

  Int_t fngoodmatch;
  Int_t fiMatchTrX;
  Int_t fiMatchTrX2;
  Int_t fiMatchTrY;
  Int_t fiMatchTrY2;
  Double_t fChi2Matching;
  //  Int_t fRun;
  
  ClassDef(HarpoRecoMatching,1);
};

class HarpoRecoReco3D : public TObject {
 public:
  
  HarpoRecoReco3D();
  HarpoRecoReco3D(Int_t ntrack_3d,Double_t doca, Double_t poca_x, Double_t poca_y, Double_t poca_z, Double_t px,Double_t py, Double_t pz,Double_t aopen,Double_t aazimutal);
  //  HarpoRecoReco3D(Int_t ntrack_3d,Double_t doca, Double_t poca_x, Double_t poca_y, Double_t poca_z, Double_t px,Double_t py, Double_t pz,Double_t aopen,Double_t aazimutal, Int_t run);
  HarpoRecoReco3D(const HarpoRecoReco3D &rec);
  virtual ~HarpoRecoReco3D();
  
  Int_t Getntrack_3d(){return fntrack_3d;}
  Double_t GetDoca(){return fDoca;}
  Double_t GetPoca_x(){return fPoca_x;}
  Double_t GetPoca_y(){return fPoca_y;}
  Double_t GetPoca_z(){return fPoca_z;}
  Double_t GetPx(){return fPx;}
  Double_t GetPy(){return fPy;}
  Double_t GetPz(){return fPz;}
  Double_t GetAopen(){return fAopen;}
  Double_t GetAazimutal(){return fAazimutal;}
  Int_t GetTypeTrack3d(Int_t i){return ftypetrack3d[i];}
  
  void Setntrack_3d(Int_t val){fntrack_3d = val;}
  void SetDoca(Double_t val){ fDoca=val;}
  void SetPoca_x(Double_t val){ fPoca_x=val;}
  void SetPoca_y(Double_t val){ fPoca_y=val;}
  void SetPoca_z(Double_t val){ fPoca_z=val;}
  void SetPx(Double_t val){ fPx=val;}
  void SetPy(Double_t val){ fPy=val;}
  void SetPz(Double_t val){ fPz=val;}
  void SetAopen(Double_t val){ fAopen=val;}
  void SetAazimutal(Double_t val){ fAazimutal=val;}
  void SetTypeTrack3d(Int_t i, Int_t val){ftypetrack3d[i]=val;}
 private:



  Int_t fntrack_3d;
  Double_t fDoca;
  Double_t fPoca_x;
  Double_t fPoca_y;
  Double_t fPoca_z;
  Double_t fPx;
  Double_t fPy;
  Double_t fPz;
  Double_t fAopen;
  Double_t fAazimutal;
  Double_t ftypetrack3d[7];
  
  ClassDef(HarpoRecoReco3D,1);
};


class HarpoRecoEvent : public TObject {

 public:
  
  HarpoRecoEvent();
  ~HarpoRecoEvent();

  void SetClusters(HarpoRecoClusters* val, Int_t nrec){
    if(nrec>=fClustersArray->GetEntries()){AddClusters(val); return;}
    if(nrec>=kMaxNclusters) return;
    new((*fClustersArray)[nrec]) HarpoRecoClusters(*val);
  }
  void SetTracks(HarpoRecoTracks* val, Int_t nrec){
    if(val->InheritsFrom("HarpoRecoHoughTracks")){
      if(nrec>=fHoughTracksArray->GetEntries()){AddTracks(val); return;}
      if(nrec>=2*kMaxNtracks) return;
      new((*fHoughTracksArray)[nrec]) HarpoRecoHoughTracks(*(HarpoRecoHoughTracks*)val);
    }
    if(val->InheritsFrom("HarpoRecoKalmanTracks")){
      if(nrec>=fKalmanTracksArray->GetEntries()){AddTracks(val); return;}
      if(nrec>=2*kMaxNtracks) return;
      new((*fKalmanTracksArray)[nrec]) HarpoRecoKalmanTracks(*(HarpoRecoKalmanTracks*)val);
    }
  }
  void SetMatching(HarpoRecoMatching* val, Int_t nrec){
    if(nrec>=fMatchingArray->GetEntries()){AddMatching(val); return;}
    if(nrec>=kMaxNtracks) return;
    new((*fMatchingArray)[nrec]) HarpoRecoMatching(*val);
  }
  void SetReco3D(HarpoRecoReco3D* val, Int_t nrec){
    if(nrec>=fReco3DArray->GetEntries()){AddReco3D(val); return;}
    if(nrec>=kMaxNtracks) return;
    new((*fReco3DArray)[nrec]) HarpoRecoReco3D(*val);
  }
  void SetVertex(HarpoRecoVertex* val, Int_t nrec){
    if(nrec>=fVertexArray->GetEntries()){AddVertex(val); return;}
    if(nrec>=kMaxNvertex) return;
    new((*fVertexArray)[nrec]) HarpoRecoVertex(*val);
  }
  void SetVertex3D(HarpoRecoVertex3D* val, Int_t nrec){
    if(nrec>=fVertex3DArray->GetEntries()){AddVertex3D(val); return;}
    if(nrec>=kMaxNvertex3D) return;
    new((*fVertex3DArray)[nrec]) HarpoRecoVertex3D(*val);
  }
  void AddClusters(HarpoRecoClusters* val){
    if(fClustersArray->GetEntries()>=kMaxNclusters) return;
    new((*fClustersArray)[fClustersArray->GetEntries()]) HarpoRecoClusters(*val);
  }
  /* void AddTracks(HarpoRecoTracks* val){ */
  /*   if(fTracksArray->GetEntries()>=2*kMaxNtracks) return; */
  /*   new((*fTracksArray)[fTracksArray->GetEntries()]) HarpoRecoTracks(*val); */
  /* } */
  void AddTracks(HarpoRecoTracks* val){
    if(val->InheritsFrom("HarpoRecoHoughTracks")){
      if(fHoughTracksArray->GetEntries()>=2*kMaxNtracks) return;
      new((*fHoughTracksArray)[fHoughTracksArray->GetEntries()]) HarpoRecoHoughTracks(*(HarpoRecoHoughTracks*)val);
    }
    if(val->InheritsFrom("HarpoRecoKalmanTracks")){
      if(fKalmanTracksArray->GetEntries()>=2*kMaxNtracks) return;
      new((*fKalmanTracksArray)[fKalmanTracksArray->GetEntries()]) HarpoRecoKalmanTracks(*(HarpoRecoKalmanTracks*)val);
    }
  }
  void AddKalmanTracks(HarpoRecoKalmanTracks* val){
    Info("AddKalmanTracks","nTrK = %d",fKalmanTracksArray->GetEntries());
    if(fKalmanTracksArray->GetEntries()>=2*kMaxNtracks) return;
    new((*fKalmanTracksArray)[fKalmanTracksArray->GetEntries()]) HarpoRecoKalmanTracks(*val);
  }
  void AddHoughTracks(HarpoRecoHoughTracks* val){
    if(fHoughTracksArray->GetEntries()>=2*kMaxNtracks) return;
    new((*fHoughTracksArray)[fHoughTracksArray->GetEntries()]) HarpoRecoHoughTracks(*val);
  }
  void AddMatching(HarpoRecoMatching* val){
    if(fMatchingArray->GetEntries()>=kMaxNtracks) return;
    new((*fMatchingArray)[fMatchingArray->GetEntries()]) HarpoRecoMatching(*val);
  }
  void AddReco3D(HarpoRecoReco3D* val){
    if(fReco3DArray->GetEntries()>=kMaxNtracks) return;
    new((*fReco3DArray)[fReco3DArray->GetEntries()]) HarpoRecoReco3D(*val);
  }
  void AddVertex(HarpoRecoVertex* val){
    if(fVertexArray->GetEntries()>=kMaxNvertex) return;
    val->SetNvertex(fVertexArray->GetEntries());
    new((*fVertexArray)[fVertexArray->GetEntries()]) HarpoRecoVertex(*val);
  }
  void AddVertex3D(HarpoRecoVertex3D* val){
    if(fVertex3DArray->GetEntries()>=kMaxNvertex3D) return;
    val->SetIdVertex3D(fVertex3DArray->GetEntries());
    new((*fVertex3DArray)[fVertex3DArray->GetEntries()]) HarpoRecoVertex3D(*val);
  }
  HarpoRecoClusters* GetClusters(Int_t icl){
    if(icl>=kMaxNclusters) return 0;
    return (HarpoRecoClusters*)fClustersArray->At(icl);
  }

  void SetClustersArray(TClonesArray* a){fClustersArray = a;}
  void SetHoughTracksArray(TClonesArray* a){fHoughTracksArray = a;}
  void SetKalmanTracksArray(TClonesArray* a){fKalmanTracksArray = a;}
  void SetMatchingArray(TClonesArray* a){fMatchingArray = a;}
  void SetReco3DArray(TClonesArray* a){fReco3DArray = a;}
  void SetVertexArray(TClonesArray* a){fVertexArray = a;}
  void SetVertex3DArray(TClonesArray* a){fVertex3DArray = a;}

  void ResetClustersArray(){fClustersArray->Clear();}
  //  void ResetTracksArray(){fTracksArray->Clear();}
  void ResetTracksArray(){fHoughTracksArray->Clear();fKalmanTracksArray->Clear();}
  void ResetHoughTracksArray(){fHoughTracksArray->Clear();}
  void ResetKalmanTracksArray(){fKalmanTracksArray->Clear();}
  void ResetMatchingArray(){fMatchingArray->Clear();}
  void ResetReco3DArray(){fReco3DArray->Clear();}
  void ResetVertexArray(){fVertexArray->Clear();}
  void ResetVertex3DArray(){fVertex3DArray->Clear();}
  void Reset(){
    ResetClustersArray();
    ResetTracksArray();
    ResetMatchingArray();
    ResetReco3DArray();
    ResetVertexArray();
    ResetVertex3DArray();
  }

  TClonesArray* GetClustersArray(){return fClustersArray;}
  TClonesArray* GetHoughTracksArray(){return fHoughTracksArray;}
  TClonesArray* GetKalmanTracksArray(){return fKalmanTracksArray;}
  TClonesArray* GetTracksArray(){
    if(fTrackType == HOUGH)
      return fHoughTracksArray;
    if(fTrackType == KALMAN)
      return fKalmanTracksArray;
    return fHoughTracksArray;
  }
  TClonesArray* GetMatchingArray(){return fMatchingArray;}
  TClonesArray* GetReco3DArray(){return fReco3DArray;}
  TClonesArray* GetVertexArray(){return fVertexArray;}
  TClonesArray* GetVertex3DArray(){return fVertex3DArray;}

  Int_t GetNcl(){return fClustersArray->GetEntries();}

  Int_t GetNtracksXEvt(){return fNtracksXEvt;}
  Int_t GetNtracksYEvt(){return fNtracksYEvt;}
  Int_t GetNtracks3DEvt(){return fNtracks3DEvt;}
  Int_t GetNclXEvt(){return fNclXEvt;}
  Int_t GetNclYEvt(){return fNclYEvt;}
  Int_t GetNCclXEvt(){return fNclXEvt;}
  Int_t GetNCclYEvt(){return fNclYEvt;}
  Int_t GetNTclXEvt(){return fNclXEvt;}
  Int_t GetNTclYEvt(){return fNclYEvt;}
  Int_t GetQtotXEvt(){return fQtotXEvt;}
  Int_t GetQtotYEvt(){return fQtotYEvt;}
  Int_t GetNclTrackEvt(){return fNclTrackEvt;}
  Int_t GetTmin(){return fTmin;}
  Int_t GetTmax(){return fTmax;}
  Int_t GetXmin(){return fTmin;}
  Int_t GetXmax(){return fTmax;}
  Int_t GetYmin(){return fTmin;}
  Int_t GetYmax(){return fTmax;}
  Int_t GetXstart(){return fXstart;}
  Int_t GetYstart(){return fYstart;}
  Int_t GetTstart(){return fTstart;}

  Int_t GetTrackType(){return fTrackType;}

  
  Int_t GetEventType() {return fEventType;}

  void SetNtracksXEvt(Int_t val) {fNtracksXEvt = val;}
  void SetNtracksYEvt(Int_t val) {fNtracksYEvt = val;}
// number of different type of event
  void SetEventType(Int_t val) {fEventType = val;}

  void SetNtracks3DEvt(Int_t val) {fNtracks3DEvt = val;}
  void SetNclXEvt(Int_t val) {fNclXEvt = val;}
  void SetNclYEvt(Int_t val) {fNclYEvt = val;}
  void SetNCclXEvt(Int_t val) {fNclXEvt = val;}
  void SetNCclYEvt(Int_t val) {fNclYEvt = val;}
  void SetNTclXEvt(Int_t val) {fNclXEvt = val;}
  void SetNTclYEvt(Int_t val) {fNclYEvt = val;}
  void SetQtotXEvt(Int_t val) {fQtotXEvt = val;}
  void SetQtotYEvt(Int_t val) {fQtotYEvt = val;}
  void SetNclTrackEvt(Int_t val) {fNclTrackEvt = val;}
  void SetTmin(Int_t val) {fTmin = val;}
  void SetTmax(Int_t val) {fTmax = val;}
  void SetXmin(Int_t val) {fXmin = val;}
  void SetXmax(Int_t val) {fXmax = val;}
  void SetYmin(Int_t val) {fYmin = val;}
  void SetYmax(Int_t val) {fYmax = val;}
  void SetXstart(Double_t val){fXstart = val;}
  void SetYstart(Double_t val){fYstart = val;}
  void SetTstart(Double_t val){fTstart = val;}

  void SetTrackType(Int_t val) {fTrackType = val;}

  Int_t GetQmaxX() {return fQmaxX;}
  Int_t GetQrestX() {return fQrestX;}

  Int_t GetQmaxY() {return fQmaxY;}
  Int_t GetQrestY() {return fQrestY;}

  void SetQmaxX(Int_t val) {fQmaxX = val;}
  void SetQrestX(Int_t val) {fQrestX = val;}

  void SetQmaxY(Int_t val) {fQmaxY = val;}
  void SetQrestY(Int_t val) {fQrestY = val;}
  //void SetQmaxX(Int_t val) {fQmax = val;}

  void Summary();




  Int_t GetAngleOmega() {return fAngleOmega;}
  void SetAngleOmega(Double_t val) {fAngleOmega = val;}

 private:

  TClonesArray* fClustersArray;
  TClonesArray* fKalmanTracksArray;
  TClonesArray* fHoughTracksArray;
  TClonesArray* fMatchingArray; 
  TClonesArray* fReco3DArray;    
  TClonesArray* fVertexArray;
  TClonesArray* fVertex3DArray;

  Double_t fAngleOmega;      

  Int_t fTrackType;

  Int_t fQmaxX;
  Int_t fQrestX;
  Int_t fQmaxY;
  Int_t fQrestY;

  Int_t fNtracksXEvt;
  Int_t fNtracksYEvt;
  Int_t fNvertexXEvt;
  Int_t fNvertexYEvt;
  Int_t fNvertex3D;


  Int_t fEventType ;

  Int_t fNtracks3DEvt;
  Int_t fNclXEvt;
  Int_t fNclYEvt;
  Int_t fNCclXEvt;
  Int_t fNCclYEvt;
  Int_t fNTclXEvt;
  Int_t fNTclYEvt;
  Int_t fQtotXEvt;
  Int_t fQtotYEvt;
  Int_t fNclTrackEvt;
  Int_t fTmin;
  Int_t fTmax;
  Int_t fXmin;
  Int_t fXmax;
  Int_t fYmin;
  Int_t fYmax;

  Double_t fXstart;
  Double_t fYstart;
  Double_t fTstart;

  static const Int_t kMaxNclusters = 4000;
  static const Int_t kMaxNtracks  = 10;
  static const Int_t kMaxNvertex  = 20;
  static const Int_t kMaxNvertex3D  = 10;

  ClassDef(HarpoRecoEvent,1)  
    };

#endif