[u/mrichter/AliRoot.git] / HLT / TPCLib / OnlineDisplay / AliHLTTPCDisplayMain.h

// XEmacs -*-C++-*-
// $Id$

#ifndef ALIHLTTPCDISPLAYMAIN_H
#define ALIHLTTPCDISPLAYMAIN_H
/** \class AliHLTTPCDisplayMain
<pre>
//_____________________________________________________________
// AliHLTTPCDisplayMain
//
// Display class for the HLT events.
</pre>
*/
// Author: Jochen Thaeder <mailto:thaeder@kip.uni-heidelberg.de>
//*-- Copyright &copy ALICE HLT Group 

#include <TGeometry.h>
#include <TObject.h>
#include <TCanvas.h>

#include "AliHLTTPCTransform.h"
#include "AliHLTLogging.h"

class AliHLTTPCSpacePointData;
class AliHLTTPCTrackArray;
class AliHLTTPCDisplayCharge;
class AliHLTTPCDisplayPadRow;
class AliHLTTPCDisplayPad;
class AliHLTTPCDisplay3D;
class AliHLTTPCDisplayResiduals;
class AliHLTTPCDisplayFront;

class AliHLTTPCDisplayMain : public TObject , public AliHLTLogging {

 public:
  AliHLTTPCDisplayMain(void* pt2GUI, void (*pt2Function)(void*, Int_t));
  virtual ~AliHLTTPCDisplayMain();
  
  Int_t Connect( unsigned int cnt, const char** hostnames, unsigned short* ports,Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom" );
  Int_t Disconnect();
  
  Int_t ReadData(Bool_t nextSwitch = kTRUE);
  void ReadRawData();
  void ReadClusterData();
  void ReadTrackData();

  void DisplayEvent(Bool_t newRawSlice = kFALSE);
  void SaveHistograms();

  /*
   * **********************************
   *              SETUP
   * **********************************
   */
  void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
  void SetupTracks();


  /*
   * **********************************
   *              SETTER
   * **********************************
   */
  void SetConnectionStatus(Bool_t f) {fConnect = f;}

  // canvas ----
  void SetCanvasCharge(TCanvas *f){fCanvasCharge = f;}
  void SetCanvasPadRow(TCanvas *f){fCanvasPadRow = f;}
  void SetCanvasPad(TCanvas *f){fCanvasPad = f;}
  void SetCanvas3D(TCanvas *f){fCanvas3D = f;}
  void SetCanvasResiduals(TCanvas *f){fCanvasResiduals = f;}
  void SetCanvasFront(TCanvas *f){fCanvasFront = f;}
  void SetCanvasHits_S(TCanvas *f){fCanvasHits_S = f;}
  void SetCanvasQ_Track(TCanvas *f){fCanvasQ_Track = f;}
  void SetCanvasQ_S(TCanvas *f){fCanvasQ_S = f;}
  void SetCanvasPadRow_Pad(TCanvas *f){fCanvasPadRow_Pad = f;}


  // slices ----
  void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
  void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
  void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
  void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
  void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
  
  // cuts ----
  //    void SetCutHits(Int_t f){fMinHits = f;}
  //    void SetCutPt(Float_t f){fPtThreshold = f;}
  void SetCutHits(Int_t f){fCutHits = f;}
  void SetCutPt(Float_t f){fCutPt = f;}
  void SetCutPsi(Float_t f){fCutPsi = f;}
  void SetCutLambda(Float_t f){fCutLambda = f;}
  void SetCutS(Float_t f){fCut_S = f;}
  void SetIncidentPadrow(Int_t f){fCutPadrow = f;}
  
  // 3D display ----
  void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
  void SetKeepView(Bool_t f){fKeepView = f;} 
  void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;} 
  void Set3DRawSwitch(Int_t f) {fSwitch3DRaw = f;}
  void SetTheta(Float_t f) {fTheta = f;}

  // raw ----
  void SetZeroSuppression(Bool_t f){fZeroSuppression = f;}
  //     -- pad/padrow
  void SetPad(Int_t f){fPad = f;}
  void SetPadRow(Int_t f){fPadRow = f; fNPads = AliHLTTPCTransform::GetNPads(f); }
  void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
  void SetSplitPadRow(Bool_t f){fSplitPadRow = f;}
  //     -- front
  void SetFrontDataSwitch(Int_t f){fFrontDataSwitch = f;}
  void SetTimeBinMinMax(Int_t f1, Int_t f2){fTimeBinMin = f1; fTimeBinMax = f2; }
  void SetSplitFront(Bool_t f){fSplitFront = f;}

  // track ----
  void SetSelectTrack(Int_t f) {fSelectTrack = f;}
  void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
  void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
  void SetSelectCluster(Int_t f) {fSelectCluster = f;}

  /*
   * **********************************
   *              GETTER
   * **********************************
   */

    
    Bool_t GetConnectionStatus() {return fConnect;}
    ULong64_t GetEventID() {return fEventID;}

    AliHLTTPCSpacePointData* GetSpacePointDataPointer(Int_t slice,Int_t patch){return fClusters[slice][patch];}
    AliHLTTPCTrackArray* GetTrackArrayPointer() {return fTracks;}
    AliHLTTPCDisplayPadRow * GetPadRowPointer() {return fDisplayPadRow;}
    AliHLTTPCDisplayPad * GetPadPointer() {return fDisplayPad;}

    // canvas ----
    TCanvas * GetCanvasHits_S(){return fCanvasHits_S;}
    TCanvas * GetCanvasQ_Track(){return fCanvasQ_Track;}
    TCanvas * GetCanvasQ_S(){return fCanvasQ_S;}
    TCanvas * GetCanvasResiduals(){return fCanvasResiduals;}
    TCanvas * GetCanvasCharge(){return fCanvasCharge;}
    TCanvas * GetCanvasPadRow(){return fCanvasPadRow;}
    TCanvas * GetCanvasPad(){return fCanvasPad;}
    TCanvas * GetCanvas3D(){return fCanvas3D;}
    TCanvas * GetCanvasFront(){return fCanvasFront;}

    // cuts ----
    Int_t GetCutHits(){return fCutHits;}
    Float_t GetCutPt(){return fCutPt;}
    Float_t GetCutPsi(){return fCutPsi;}
    Float_t GetCutLambda(){return fCutLambda;}
    Float_t GetCutS(){return fCut_S;}
    Int_t GetIncidentPadrow(){return fCutPadrow;}

    Int_t GetNumberSpacePoints(Int_t slice,Int_t patch){return fNcl[slice][patch];}
    Int_t GetTracksPerSlice(Int_t slice){return fTracksPerSlice[slice];}
    Bool_t GetDisplaySlice(Int_t slice){ return fSliceArray[slice];}

    Int_t GetSelectCluster(){return fSelectCluster;}
    Bool_t GetSelectTrackSwitch() {return fSelectTrackSwitch;}
    Int_t GetSelectTrack() {return fSelectTrack;}
    Int_t GetSelectTrackSlice() {return fSelectTrackSlice;}

    Int_t GetGlobalTrack(Int_t slice);
  
    // raw ----
    Bool_t GetZeroSuppression(){return fZeroSuppression;}
    //     -- pad/padrow
    Int_t GetPad(){return fPad;}
    Int_t GetNPads(){return fNPads;}
    Int_t GetPadRow(){return fPadRow;}
    Int_t GetSlicePadRow(){return fSlicePadRow;}
    Bool_t GetSplitPadRow(){return fSplitPadRow;}
    //     -- front
    Int_t GetNTimeBins(){return fgNTimeBins;}
    Int_t GetFrontDataSwitch(){return fFrontDataSwitch;}
    Int_t GetTimeBinMin(){return fTimeBinMin;}
    Int_t GetTimeBinMax(){return fTimeBinMax;}
    Bool_t GetSplitFront(){return fSplitFront;}
  

    Int_t GetLineColor(){return fLineColor;}
    Int_t GetBackColor(){return fBackColor;}
    Bool_t GetKeepView(){return fKeepView;}
    Float_t GetTheta(){return fTheta;}
    Float_t GetPhi(){return fPhi;}

    Bool_t Get3DSwitchTracks() {return fSwitch3DTracks;}
    Bool_t Get3DSwitchCluster() {return fSwitch3DCluster;}
    Bool_t Get3DSwitchPadRow() {return fSwitch3DPadRow;}
    Bool_t Get3DSwitchGeometry() {return fSwitch3DGeometry;}
    Int_t  Get3DSwitchRaw() {return fSwitch3DRaw;}

    Int_t GetTrackParamNHits(){ return fTrackParam.nHits;}
    /*    
#if 0
    Char_t GetTrackParamSlice(){ return Char_t GetTrackParamId();
      Char_t GetTrackParamKappa());
    Char_t GetTrackParamPt());
Char_t GetTrackParamNHits());
Char_t GetTrackParamCharge());
Char_t GetTrackParamRadius());
Char_t GetTrackParamPhi0());
Char_t GetTrackParamPsi());
Char_t GetTrackParamLambda());
Char_t GetTrackParamBfield());
    #endif
    */

    // EXISTS
    Bool_t ExistsRawData() {return fExistsRawData;}   
    Bool_t ExistsClusterData() {return fExistsClusterData;}   
    Bool_t ExistsTrackData() {return fExistsTrackData;}   

    // EVENTS
    void ExecPadEvent(Int_t event, Int_t x, Int_t y, TObject *selected);

    // Callback Handler
    void * fPt2Gui;
    void (*fPadCallback)(void*, Int_t);

    struct AliHLTTPCTrackParameter{
	Int_t nHits;
	Int_t charge;
	Double_t kappa;
	Double_t radius;
	Int_t slice;
	Double_t phi0;
	Double_t psi;
	Double_t lambda;
	Double_t pt;
	Int_t id;
	Double_t bfield;
	Double_t s;
    };
    
    void* fReader;                 // really HOMERReader*

    UInt_t fRawData[159][140][1024];                    // Raw Data of one Slice
    UInt_t fRawDataZeroSuppressed[159][140][1024];      // Raw Data of one Slice zero suppressed

    AliHLTTPCTrackParameter fTrackParam;

// ---------------------------------------------------
 private:
    AliHLTTPCDisplayMain(const AliHLTTPCDisplayMain &/*d*/):TObject(){;}
    AliHLTTPCDisplayMain& operator=(const AliHLTTPCDisplayMain &/*d*/){return *this;}
      
    void SetSliceArray();          // Fill Array with slices which 

    // ** global constants **
    Int_t fgNTimeBins;             // Number of TimeBins 

    // **  HOMER parameter / connection / data exist **
    ULong64_t fEventID;            // Event ID

    Bool_t fConnect;               // Connection status
  
    Bool_t fExistsRawData;         // Raw data present
    Bool_t fExistsClusterData;     // Cluster data present
    Bool_t fExistsTrackData;       // Track data present

    // ** pointer to display classes **
    AliHLTTPCDisplayCharge* fDisplayCharge; 
    AliHLTTPCDisplayPadRow* fDisplayPadRow;
    AliHLTTPCDisplayPad* fDisplayPad;
    AliHLTTPCDisplay3D* fDisplay3D;
    AliHLTTPCDisplayResiduals* fDisplayResiduals;
    AliHLTTPCDisplayFront * fDisplayFront;

    // ** pointer to canvases in GUI ** 
    TCanvas * fCanvasCharge;
    TCanvas * fCanvasPadRow;
    TCanvas * fCanvasPad;
    TCanvas * fCanvas3D;
    TCanvas * fCanvasResiduals;
    TCanvas * fCanvasFront;
    TCanvas * fCanvasHits_S;
    TCanvas * fCanvasQ_Track;
    TCanvas * fCanvasQ_S;
    TCanvas * fCanvasPadRow_Pad;

    Int_t fTracksPerSlice[36];     // TrackCount per slice

    // ** cluster / tarck container **
    AliHLTTPCSpacePointData *fClusters[36][6]; 
    AliHLTTPCTrackArray *fTracks; 
    
    UInt_t fNcl[36][6];            // Number of cluster

    // ** selected selected slice(s) **
    Int_t fMinSlice;               // Min slice
    Int_t fMaxSlice;               // Max slice
    Bool_t fSlicePair;             // Pair of slices;
    Bool_t fSliceArray[36];        // Array if slice should be drawn or not

    // ** select type of clusters **
    Int_t fSelectCluster;          // select all=0, used=1, unused=2 cluster

    // ** raw data variables **
    Bool_t fZeroSuppression;       // enable zero suppression
    //     -- pad/padrow
    Int_t fPad;                    // pad
    Int_t fNPads;                  // number of pads in row
    Int_t fPadRow;                 // padrow
    Int_t fSlicePadRow;            // slice where padrow is in
    Bool_t fSplitPadRow;           // Split PadRow Canvas
    //     -- front
    Int_t fFrontDataSwitch;        // select average/sum/maximum
    Int_t fTimeBinMin;             // min TimeBin
    Int_t fTimeBinMax;             // max TimeBin
    Bool_t fSplitFront;            // Split Front Canvas

  
    // ** select tracks **
    Bool_t fSelectTrackSwitch;     // switch ti single track mode
    Int_t fSelectTrack;            // select single track
    Int_t fSelectTrackSlice;       // select slice for single track


    // ** cuts on tracks **
    Int_t fCutHits;
    Float_t fCutPt;
    Float_t fCutPsi;
    Float_t fCutLambda;
    Float_t fCut_S;
    Int_t fCutPadrow;

    // ** "keepview", angles and colors for 3D view **
    Bool_t fKeepView;              // Keep View when redisplaying

    Float_t fTheta;
    Float_t fPhi;

    Int_t fBackColor;              // Background color
    Int_t fLineColor;              // Line color

    // ** 3D switches **
    Bool_t fSwitch3DCluster;
    Bool_t fSwitch3DTracks;
    Bool_t fSwitch3DPadRow;
    Bool_t fSwitch3DGeometry;
    Int_t fSwitch3DRaw;    

    ClassDef(AliHLTTPCDisplayMain,0) //Display class
};
#endif
Commit	Line	Data
78b557c2	1	// XEmacs --C++--
	2	// $Id$
	3
	4	#ifndef ALIHLTTPCDISPLAYMAIN_H
	5	#define ALIHLTTPCDISPLAYMAIN_H
	6	/** \class AliHLTTPCDisplayMain
	7	<pre>
	8	//_____________________________________________________________
	9	// AliHLTTPCDisplayMain
	10	//
	11	// Display class for the HLT events.
	12	</pre>
	13	*/
	14	// Author: Jochen Thaeder <mailto:thaeder@kip.uni-heidelberg.de>
	15	//*-- Copyright &copy ALICE HLT Group
	16
	17	#include <TGeometry.h>
	18	#include <TObject.h>
	19	#include <TCanvas.h>
	20
	21	#include "AliHLTTPCTransform.h"
	22	#include "AliHLTLogging.h"
	23
	24	class AliHLTTPCSpacePointData;
	25	class AliHLTTPCTrackArray;
	26	class AliHLTTPCDisplayCharge;
	27	class AliHLTTPCDisplayPadRow;
	28	class AliHLTTPCDisplayPad;
	29	class AliHLTTPCDisplay3D;
	30	class AliHLTTPCDisplayResiduals;
	31	class AliHLTTPCDisplayFront;
	32
	33	class AliHLTTPCDisplayMain : public TObject , public AliHLTLogging {
	34
	35	public:
5235c3e9	36	AliHLTTPCDisplayMain(void* pt2GUI, void (pt2Function)(void, Int_t));
	37	virtual ~AliHLTTPCDisplayMain();
	38
	39	Int_t Connect( unsigned int cnt, const char** hostnames, unsigned short* ports,Char_t *gfile="$(ALIHLT_BASEDIR)/geo/alice.geom" );
	40	Int_t Disconnect();
	41
	42	Int_t ReadData(Bool_t nextSwitch = kTRUE);
	43	void ReadRawData();
	44	void ReadClusterData();
	45	void ReadTrackData();
	46
	47	void DisplayEvent(Bool_t newRawSlice = kFALSE);
	48	void SaveHistograms();
	49
	50	/*
	51	* **********************************
	52	* SETUP
	53	* **********************************
	54	*/
	55	void SetupCluster(Int_t slice, Int_t patch, UInt_t nofClusters, AliHLTTPCSpacePointData* data);
	56	void SetupTracks();
	57
	58
	59	/*
	60	* **********************************
	61	* SETTER
	62	* **********************************
	63	*/
	64	void SetConnectionStatus(Bool_t f) {fConnect = f;}
	65
	66	// canvas ----
	67	void SetCanvasCharge(TCanvas *f){fCanvasCharge = f;}
	68	void SetCanvasPadRow(TCanvas *f){fCanvasPadRow = f;}
	69	void SetCanvasPad(TCanvas *f){fCanvasPad = f;}
	70	void SetCanvas3D(TCanvas *f){fCanvas3D = f;}
	71	void SetCanvasResiduals(TCanvas *f){fCanvasResiduals = f;}
	72	void SetCanvasFront(TCanvas *f){fCanvasFront = f;}
	73	void SetCanvasHits_S(TCanvas *f){fCanvasHits_S = f;}
	74	void SetCanvasQ_Track(TCanvas *f){fCanvasQ_Track = f;}
	75	void SetCanvasQ_S(TCanvas *f){fCanvasQ_S = f;}
	76	void SetCanvasPadRow_Pad(TCanvas *f){fCanvasPadRow_Pad = f;}
	77
	78
	79	// slices ----
	80	void SetSlices(){fMinSlice = 0; fMaxSlice = 35; fSlicePair = kFALSE; SetSliceArray();}
	81	void SetSlices(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kFALSE; SetSliceArray();}
	82	void SetSlices(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kFALSE; SetSliceArray();}
	83	void SetSlicesPair(Int_t s){fMinSlice = s; fMaxSlice = s; fSlicePair = kTRUE; SetSliceArray();}
	84	void SetSlicesPair(Int_t mins, Int_t maxs){fMinSlice = mins; fMaxSlice = maxs; fSlicePair = kTRUE; SetSliceArray();}
	85
	86	// cuts ----
	87	// void SetCutHits(Int_t f){fMinHits = f;}
	88	// void SetCutPt(Float_t f){fPtThreshold = f;}
	89	void SetCutHits(Int_t f){fCutHits = f;}
	90	void SetCutPt(Float_t f){fCutPt = f;}
	91	void SetCutPsi(Float_t f){fCutPsi = f;}
	92	void SetCutLambda(Float_t f){fCutLambda = f;}
	93	void SetCutS(Float_t f){fCut_S = f;}
	94	void SetIncidentPadrow(Int_t f){fCutPadrow = f;}
	95
	96	// 3D display ----
	97	void SetInvert() {Int_t tmp = fBackColor; fBackColor = fLineColor; fLineColor = tmp; }
	98	void SetKeepView(Bool_t f){fKeepView = f;}
	99	void SetSwitches(Bool_t f1, Bool_t f2, Bool_t f3, Bool_t f4) {fSwitch3DTracks = f1; fSwitch3DCluster = f2; fSwitch3DPadRow = f3; fSwitch3DGeometry = f4;}
100	void Set3DRawSwitch(Int_t f) {fSwitch3DRaw = f;}
101	void SetTheta(Float_t f) {fTheta = f;}
102
103	// raw ----
104	void SetZeroSuppression(Bool_t f){fZeroSuppression = f;}
105	// -- pad/padrow
106	void SetPad(Int_t f){fPad = f;}
107	void SetPadRow(Int_t f){fPadRow = f; fNPads = AliHLTTPCTransform::GetNPads(f); }
108	void SetSlicePadRow(Int_t f){fSlicePadRow = f;}
109	void SetSplitPadRow(Bool_t f){fSplitPadRow = f;}
110	// -- front
111	void SetFrontDataSwitch(Int_t f){fFrontDataSwitch = f;}
112	void SetTimeBinMinMax(Int_t f1, Int_t f2){fTimeBinMin = f1; fTimeBinMax = f2; }
113	void SetSplitFront(Bool_t f){fSplitFront = f;}
114
115	// track ----
116	void SetSelectTrack(Int_t f) {fSelectTrack = f;}
117	void SetSelectTrackSlice(Int_t f) {fSelectTrackSlice = f;}
118	void SetSelectTrackSwitch(Bool_t f) {fSelectTrackSwitch = f;}
119	void SetSelectCluster(Int_t f) {fSelectCluster = f;}
120
121	/*
122	* **********************************
123	* GETTER
124	* **********************************
125	*/
78b557c2	126
78b557c2	127
78b557c2	128	Bool_t GetConnectionStatus() {return fConnect;}
5235c3e9	129	ULong64_t GetEventID() {return fEventID;}
78b557c2	130
	131	AliHLTTPCSpacePointData* GetSpacePointDataPointer(Int_t slice,Int_t patch){return fClusters[slice][patch];}
	132	AliHLTTPCTrackArray* GetTrackArrayPointer() {return fTracks;}
	133	AliHLTTPCDisplayPadRow * GetPadRowPointer() {return fDisplayPadRow;}
	134	AliHLTTPCDisplayPad * GetPadPointer() {return fDisplayPad;}
	135
	136	// canvas ----
	137	TCanvas * GetCanvasHits_S(){return fCanvasHits_S;}
	138	TCanvas * GetCanvasQ_Track(){return fCanvasQ_Track;}
	139	TCanvas * GetCanvasQ_S(){return fCanvasQ_S;}
	140	TCanvas * GetCanvasResiduals(){return fCanvasResiduals;}
	141	TCanvas * GetCanvasCharge(){return fCanvasCharge;}
	142	TCanvas * GetCanvasPadRow(){return fCanvasPadRow;}
	143	TCanvas * GetCanvasPad(){return fCanvasPad;}
	144	TCanvas * GetCanvas3D(){return fCanvas3D;}
	145	TCanvas * GetCanvasFront(){return fCanvasFront;}
	146
	147	// cuts ----
	148	Int_t GetCutHits(){return fCutHits;}
	149	Float_t GetCutPt(){return fCutPt;}
	150	Float_t GetCutPsi(){return fCutPsi;}
	151	Float_t GetCutLambda(){return fCutLambda;}
	152	Float_t GetCutS(){return fCut_S;}
	153	Int_t GetIncidentPadrow(){return fCutPadrow;}
	154
	155	Int_t GetNumberSpacePoints(Int_t slice,Int_t patch){return fNcl[slice][patch];}
	156	Int_t GetTracksPerSlice(Int_t slice){return fTracksPerSlice[slice];}
	157	Bool_t GetDisplaySlice(Int_t slice){ return fSliceArray[slice];}
	158
	159	Int_t GetSelectCluster(){return fSelectCluster;}
	160	Bool_t GetSelectTrackSwitch() {return fSelectTrackSwitch;}
	161	Int_t GetSelectTrack() {return fSelectTrack;}
	162	Int_t GetSelectTrackSlice() {return fSelectTrackSlice;}
	163
	164	Int_t GetGlobalTrack(Int_t slice);
5235c3e9	165
	166	// raw ----
	167	Bool_t GetZeroSuppression(){return fZeroSuppression;}
	168	// -- pad/padrow
78b557c2	169	Int_t GetPad(){return fPad;}
5235c3e9	170	Int_t GetNPads(){return fNPads;}
78b557c2	171	Int_t GetPadRow(){return fPadRow;}
	172	Int_t GetSlicePadRow(){return fSlicePadRow;}
	173	Bool_t GetSplitPadRow(){return fSplitPadRow;}
5235c3e9	174	// -- front
	175	Int_t GetNTimeBins(){return fgNTimeBins;}
	176	Int_t GetFrontDataSwitch(){return fFrontDataSwitch;}
	177	Int_t GetTimeBinMin(){return fTimeBinMin;}
	178	Int_t GetTimeBinMax(){return fTimeBinMax;}
	179	Bool_t GetSplitFront(){return fSplitFront;}
	180
78b557c2	181
78b557c2	182
	183	Int_t GetLineColor(){return fLineColor;}
	184	Int_t GetBackColor(){return fBackColor;}
	185	Bool_t GetKeepView(){return fKeepView;}
	186	Float_t GetTheta(){return fTheta;}
	187	Float_t GetPhi(){return fPhi;}
	188
	189	Bool_t Get3DSwitchTracks() {return fSwitch3DTracks;}
	190	Bool_t Get3DSwitchCluster() {return fSwitch3DCluster;}
	191	Bool_t Get3DSwitchPadRow() {return fSwitch3DPadRow;}
	192	Bool_t Get3DSwitchGeometry() {return fSwitch3DGeometry;}
5235c3e9	193	Int_t Get3DSwitchRaw() {return fSwitch3DRaw;}
78b557c2	194
78b557c2	195	Int_t GetTrackParamNHits(){ return fTrackParam.nHits;}
5235c3e9	196	/*
78b557c2	197	#if 0
78b557c2	198	Char_t GetTrackParamSlice(){ return Char_t GetTrackParamId();
5235c3e9	199	Char_t GetTrackParamKappa());
78b557c2	200	Char_t GetTrackParamPt());
	201	Char_t GetTrackParamNHits());
	202	Char_t GetTrackParamCharge());
	203	Char_t GetTrackParamRadius());
	204	Char_t GetTrackParamPhi0());
	205	Char_t GetTrackParamPsi());
	206	Char_t GetTrackParamLambda());
	207	Char_t GetTrackParamBfield());
5235c3e9	208	#endif
	209	*/
	210
78b557c2	211	// EXISTS
	212	Bool_t ExistsRawData() {return fExistsRawData;}
	213	Bool_t ExistsClusterData() {return fExistsClusterData;}
	214	Bool_t ExistsTrackData() {return fExistsTrackData;}
	215
	216	// EVENTS
	217	void ExecPadEvent(Int_t event, Int_t x, Int_t y, TObject *selected);
	218
	219	// Callback Handler
	220	void * fPt2Gui;
	221	void (fPadCallback)(void, Int_t);
	222
	223	struct AliHLTTPCTrackParameter{
	224	Int_t nHits;
	225	Int_t charge;
	226	Double_t kappa;
	227	Double_t radius;
	228	Int_t slice;
	229	Double_t phi0;
	230	Double_t psi;
	231	Double_t lambda;
	232	Double_t pt;
	233	Int_t id;
	234	Double_t bfield;
	235	Double_t s;
	236	};
	237
5235c3e9	238	void* fReader; // really HOMERReader*
	239
	240	UInt_t fRawData[159][140][1024]; // Raw Data of one Slice
	241	UInt_t fRawDataZeroSuppressed[159][140][1024]; // Raw Data of one Slice zero suppressed
	242
78b557c2	243	AliHLTTPCTrackParameter fTrackParam;
	244
	245	// ---------------------------------------------------
	246	private:
5235c3e9	247	AliHLTTPCDisplayMain(const AliHLTTPCDisplayMain &/d/):TObject(){;}
78b557c2	248	AliHLTTPCDisplayMain& operator=(const AliHLTTPCDisplayMain &/d/){return *this;}
5235c3e9	249
	250	void SetSliceArray(); // Fill Array with slices which
	251
	252	// global constants
	253	Int_t fgNTimeBins; // Number of TimeBins
	254
	255	// HOMER parameter / connection / data exist
	256	ULong64_t fEventID; // Event ID
78b557c2	257
	258	Bool_t fConnect; // Connection status
	259
	260	Bool_t fExistsRawData; // Raw data present
	261	Bool_t fExistsClusterData; // Cluster data present
	262	Bool_t fExistsTrackData; // Track data present
	263
5235c3e9	264	// pointer to display classes
	265	AliHLTTPCDisplayCharge* fDisplayCharge;
	266	AliHLTTPCDisplayPadRow* fDisplayPadRow;
	267	AliHLTTPCDisplayPad* fDisplayPad;
	268	AliHLTTPCDisplay3D* fDisplay3D;
	269	AliHLTTPCDisplayResiduals* fDisplayResiduals;
	270	AliHLTTPCDisplayFront * fDisplayFront;
	271
	272	// pointer to canvases in GUI
	273	TCanvas * fCanvasCharge;
	274	TCanvas * fCanvasPadRow;
	275	TCanvas * fCanvasPad;
	276	TCanvas * fCanvas3D;
	277	TCanvas * fCanvasResiduals;
	278	TCanvas * fCanvasFront;
	279	TCanvas * fCanvasHits_S;
	280	TCanvas * fCanvasQ_Track;
	281	TCanvas * fCanvasQ_S;
	282	TCanvas * fCanvasPadRow_Pad;
78b557c2	283
	284	Int_t fTracksPerSlice[36]; // TrackCount per slice
	285
5235c3e9	286	// cluster / tarck container
78b557c2	287	AliHLTTPCSpacePointData *fClusters[36][6];
	288	AliHLTTPCTrackArray *fTracks;
	289
	290	UInt_t fNcl[36][6]; // Number of cluster
	291
5235c3e9	292	// selected selected slice(s)
78b557c2	293	Int_t fMinSlice; // Min slice
	294	Int_t fMaxSlice; // Max slice
	295	Bool_t fSlicePair; // Pair of slices;
	296	Bool_t fSliceArray[36]; // Array if slice should be drawn or not
	297
5235c3e9	298	// select type of clusters
78b557c2	299	Int_t fSelectCluster; // select all=0, used=1, unused=2 cluster
78b557c2	300
5235c3e9	301	// raw data variables
	302	Bool_t fZeroSuppression; // enable zero suppression
	303	// -- pad/padrow
	304	Int_t fPad; // pad
	305	Int_t fNPads; // number of pads in row
	306	Int_t fPadRow; // padrow
	307	Int_t fSlicePadRow; // slice where padrow is in
	308	Bool_t fSplitPadRow; // Split PadRow Canvas
	309	// -- front
	310	Int_t fFrontDataSwitch; // select average/sum/maximum
	311	Int_t fTimeBinMin; // min TimeBin
	312	Int_t fTimeBinMax; // max TimeBin
	313	Bool_t fSplitFront; // Split Front Canvas
	314
	315
	316
	317	// select tracks
	318	Bool_t fSelectTrackSwitch; // switch ti single track mode
	319	Int_t fSelectTrack; // select single track
	320	Int_t fSelectTrackSlice; // select slice for single track
	321
	322
	323	// cuts on tracks
78b557c2	324	Int_t fCutHits;
	325	Float_t fCutPt;
	326	Float_t fCutPsi;
	327	Float_t fCutLambda;
	328	Float_t fCut_S;
	329	Int_t fCutPadrow;
	330
5235c3e9	331	// "keepview", angles and colors for 3D view
	332	Bool_t fKeepView; // Keep View when redisplaying
	333
	334	Float_t fTheta;
	335	Float_t fPhi;
	336
78b557c2	337	Int_t fBackColor; // Background color
78b557c2	338	Int_t fLineColor; // Line color
78b557c2	339
5235c3e9	340	// 3D switches
78b557c2	341	Bool_t fSwitch3DCluster;
	342	Bool_t fSwitch3DTracks;
	343	Bool_t fSwitch3DPadRow;
	344	Bool_t fSwitch3DGeometry;
5235c3e9	345	Int_t fSwitch3DRaw;
78b557c2	346
	347	ClassDef(AliHLTTPCDisplayMain,0) //Display class
	348	};
	349	#endif