[u/mrichter/AliRoot.git] / HLT / ITS / tracking / AliHLTITSLayer.h

// ************************************************************************
// This file is property of and copyright by the ALICE HLT Project        *
// ALICE Experiment at CERN, All rights reserved.                         *
// See cxx source for full Copyright notice                               *
//                                                                        *
//*************************************************************************

#ifndef ALIHLTITSLAYER_H
#define ALIHLTITSLAYER_H

#include "AliHLTITSDetector.h"
#include "AliITSRecoParam.h"

/**
 * @class AliHLTITSLayer
 *
 * The AliHLTTPCCAHit class is the internal representation
 * of the TPC clusters for the AliHLTTPCCATracker algorithm.
 *
 */
class AliHLTITSLayer 
{
 public:
  AliHLTITSLayer();
  AliHLTITSLayer(Double_t r, Double_t p, Double_t z, Int_t nl, Int_t nd);
  ~AliHLTITSLayer();
  Int_t InsertCluster(AliITSRecPoint *c);
  void  SortClusters();
  void ResetClusters();
  void ResetWeights();
  void SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin,Double_t ymax);
  const AliITSRecPoint *GetNextCluster(Int_t &ci,Bool_t test=kFALSE);
  void ResetRoad();
  Double_t GetRoad() const {return fRoad;}
  Double_t GetR() const {return fR;}
  Int_t FindClusterIndex(Float_t z) const;
  AliITSRecPoint *GetCluster(Int_t i) const {return i<fN? fClusters[i]:0;} 
  Float_t  *GetWeight(Int_t i)  {return i<fN ?&fClusterWeight[i]:0;}
  AliHLTITSDetector &GetDetector(Int_t n) const { return fDetectors[n]; }
  Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
  Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
  Int_t InRoad() const ;
  Int_t GetNumberOfClusters() const {return fN;}
  Int_t GetNladders() const {return fNladders;}
  Int_t GetNdetectors() const {return fNdetectors;}
  Int_t GetSkip() const {return fSkip;}
  void  SetSkip(Int_t skip){fSkip=skip;}
  void IncAccepted(){fAccepted++;}
  Int_t GetAccepted() const {return fAccepted;}    
  Int_t GetClusterTracks(Int_t i, Int_t j) const {return fClusterTracks[i][j];}
  void SetClusterTracks(Int_t i, Int_t j, Int_t c) {fClusterTracks[i][j]=c;}

 protected:

  AliHLTITSLayer(const AliHLTITSLayer& layer);
  AliHLTITSLayer & operator=(const AliHLTITSLayer& layer){
    this->~AliHLTITSLayer();new(this) AliHLTITSLayer(layer);
    return *this;}
  Double_t fR;                // mean radius of this layer
  Double_t fPhiOffset;        // offset of the first detector in Phi
  Int_t fNladders;            // number of ladders
  Double_t fZOffset;          // offset of the first detector in Z
  Int_t fNdetectors;          // detectors/ladder
  AliHLTITSDetector *fDetectors; // array of detectors
  Int_t fN;                   // number of clusters
  AliITSRecPoint *fClusters[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
  Int_t        fClusterIndex[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
  Float_t fY[AliITSRecoParam::fgkMaxClusterPerLayer];                // y position of the clusters      
  Float_t fZ[AliITSRecoParam::fgkMaxClusterPerLayer];                // z position of the clusters      
  Float_t fYB[2];                                       // ymin and ymax
  //
  AliITSRecPoint *fClusters5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters -     slice in y
  Int_t        fClusterIndex5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters -     slice in y    
  Float_t fY5[6][AliITSRecoParam::fgkMaxClusterPerLayer5];                // y position of the clusters  slice in y    
  Float_t fZ5[6][AliITSRecoParam::fgkMaxClusterPerLayer5];                // z position of the clusters  slice in y 
  Int_t fN5[6];                                       // number of cluster in slice
  Float_t fDy5;                                       //delta y
  Float_t fBy5[6][2];                                    //slice borders
  //
  AliITSRecPoint *fClusters10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters -     slice in y
  Int_t        fClusterIndex10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters -     slice in y    
  Float_t fY10[11][AliITSRecoParam::fgkMaxClusterPerLayer10];                // y position of the clusters  slice in y    
  Float_t fZ10[11][AliITSRecoParam::fgkMaxClusterPerLayer10];                // z position of the clusters  slice in y 
  Int_t fN10[11];                                       // number of cluster in slice
  Float_t fDy10;                                        // delta y
  Float_t fBy10[11][2];                                 // slice borders
  //
  AliITSRecPoint *fClusters20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters -     slice in y
  Int_t        fClusterIndex20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters -     slice in y    
  Float_t fY20[21][AliITSRecoParam::fgkMaxClusterPerLayer20];                // y position of the clusters  slice in y    
  Float_t fZ20[21][AliITSRecoParam::fgkMaxClusterPerLayer20];                // z position of the clusters  slice in y 
  Int_t fN20[21];                                       // number of cluster in slice
  Float_t fDy20;                                        //delta y 
  Float_t fBy20[21][2];                                 //slice borders
  //
  AliITSRecPoint** fClustersCs;                         //clusters table in current slice
  Int_t   *fClusterIndexCs;                             //cluster index in current slice 
  Float_t *fYcs;                                        //y position in current slice
  Float_t *fZcs;                                        //z position in current slice
  Int_t    fNcs;                                        //number of clusters in current slice    
  Int_t fCurrentSlice;                                  //current slice
  //
  Float_t  fClusterWeight[AliITSRecoParam::fgkMaxClusterPerLayer]; // probabilistic weight of the cluster
  Int_t    fClusterTracks[4][AliITSRecoParam::fgkMaxClusterPerLayer]; //tracks registered to given cluster
  Float_t fZmax;      //    edges
  Float_t fYmin;      //   of  the
  Float_t fYmax;      //   "window"
  Int_t fI;            // index of the current cluster within the "window"
  Int_t fImax;            // index of the last cluster within the "window"    
  Int_t fSkip;     // indicates possibility to skip cluster
  Int_t fAccepted;     // accept indicator 
  Double_t fRoad;      // road defined by the cluster density
};


#endif
Commit	Line	Data
2f399afc	1	// ************************************************************************
	2	// This file is property of and copyright by the ALICE HLT Project *
	3	// ALICE Experiment at CERN, All rights reserved. *
	4	// See cxx source for full Copyright notice *
	5	// *
	6	//*************************************************************************
	7
	8	#ifndef ALIHLTITSLAYER_H
	9	#define ALIHLTITSLAYER_H
	10
	11	#include "AliHLTITSDetector.h"
	12	#include "AliITSRecoParam.h"
	13
	14	/**
	15	* @class AliHLTITSLayer
	16	*
	17	* The AliHLTTPCCAHit class is the internal representation
	18	* of the TPC clusters for the AliHLTTPCCATracker algorithm.
	19	*
	20	*/
	21	class AliHLTITSLayer
	22	{
	23	public:
	24	AliHLTITSLayer();
	25	AliHLTITSLayer(Double_t r, Double_t p, Double_t z, Int_t nl, Int_t nd);
	26	~AliHLTITSLayer();
	27	Int_t InsertCluster(AliITSRecPoint *c);
	28	void SortClusters();
	29	void ResetClusters();
	30	void ResetWeights();
	31	void SelectClusters(Double_t zmin,Double_t zmax,Double_t ymin,Double_t ymax);
	32	const AliITSRecPoint *GetNextCluster(Int_t &ci,Bool_t test=kFALSE);
	33	void ResetRoad();
	34	Double_t GetRoad() const {return fRoad;}
	35	Double_t GetR() const {return fR;}
	36	Int_t FindClusterIndex(Float_t z) const;
	37	AliITSRecPoint *GetCluster(Int_t i) const {return i<fN? fClusters[i]:0;}
	38	Float_t *GetWeight(Int_t i) {return i<fN ?&fClusterWeight[i]:0;}
	39	AliHLTITSDetector &GetDetector(Int_t n) const { return fDetectors[n]; }
	40	Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
	41	Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
	42	Int_t InRoad() const ;
	43	Int_t GetNumberOfClusters() const {return fN;}
	44	Int_t GetNladders() const {return fNladders;}
	45	Int_t GetNdetectors() const {return fNdetectors;}
	46	Int_t GetSkip() const {return fSkip;}
	47	void SetSkip(Int_t skip){fSkip=skip;}
	48	void IncAccepted(){fAccepted++;}
	49	Int_t GetAccepted() const {return fAccepted;}
	50	Int_t GetClusterTracks(Int_t i, Int_t j) const {return fClusterTracks[i][j];}
	51	void SetClusterTracks(Int_t i, Int_t j, Int_t c) {fClusterTracks[i][j]=c;}
	52
	53	protected:
	54
	55	AliHLTITSLayer(const AliHLTITSLayer& layer);
	56	AliHLTITSLayer & operator=(const AliHLTITSLayer& layer){
	57	this->~AliHLTITSLayer();new(this) AliHLTITSLayer(layer);
	58	return *this;}
	59	Double_t fR; // mean radius of this layer
	60	Double_t fPhiOffset; // offset of the first detector in Phi
	61	Int_t fNladders; // number of ladders
	62	Double_t fZOffset; // offset of the first detector in Z
	63	Int_t fNdetectors; // detectors/ladder
	64	AliHLTITSDetector *fDetectors; // array of detectors
65	Int_t fN; // number of clusters
66	AliITSRecPoint *fClusters[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
67	Int_t fClusterIndex[AliITSRecoParam::fgkMaxClusterPerLayer]; // pointers to clusters
68	Float_t fY[AliITSRecoParam::fgkMaxClusterPerLayer]; // y position of the clusters
69	Float_t fZ[AliITSRecoParam::fgkMaxClusterPerLayer]; // z position of the clusters
70	Float_t fYB[2]; // ymin and ymax
71	//
72	AliITSRecPoint *fClusters5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters - slice in y
73	Int_t fClusterIndex5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // pointers to clusters - slice in y
74	Float_t fY5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // y position of the clusters slice in y
75	Float_t fZ5[6][AliITSRecoParam::fgkMaxClusterPerLayer5]; // z position of the clusters slice in y
76	Int_t fN5[6]; // number of cluster in slice
77	Float_t fDy5; //delta y
78	Float_t fBy5[6][2]; //slice borders
79	//
80	AliITSRecPoint *fClusters10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters - slice in y
81	Int_t fClusterIndex10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // pointers to clusters - slice in y
82	Float_t fY10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // y position of the clusters slice in y
83	Float_t fZ10[11][AliITSRecoParam::fgkMaxClusterPerLayer10]; // z position of the clusters slice in y
84	Int_t fN10[11]; // number of cluster in slice
85	Float_t fDy10; // delta y
86	Float_t fBy10[11][2]; // slice borders
87	//
88	AliITSRecPoint *fClusters20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters - slice in y
89	Int_t fClusterIndex20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // pointers to clusters - slice in y
90	Float_t fY20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // y position of the clusters slice in y
91	Float_t fZ20[21][AliITSRecoParam::fgkMaxClusterPerLayer20]; // z position of the clusters slice in y
92	Int_t fN20[21]; // number of cluster in slice
93	Float_t fDy20; //delta y
94	Float_t fBy20[21][2]; //slice borders
95	//
96	AliITSRecPoint** fClustersCs; //clusters table in current slice
97	Int_t *fClusterIndexCs; //cluster index in current slice
98	Float_t *fYcs; //y position in current slice
99	Float_t *fZcs; //z position in current slice
100	Int_t fNcs; //number of clusters in current slice
101	Int_t fCurrentSlice; //current slice
102	//
103	Float_t fClusterWeight[AliITSRecoParam::fgkMaxClusterPerLayer]; // probabilistic weight of the cluster
104	Int_t fClusterTracks[4][AliITSRecoParam::fgkMaxClusterPerLayer]; //tracks registered to given cluster
105	Float_t fZmax; // edges
106	Float_t fYmin; // of the
107	Float_t fYmax; // "window"
108	Int_t fI; // index of the current cluster within the "window"
109	Int_t fImax; // index of the last cluster within the "window"
110	Int_t fSkip; // indicates possibility to skip cluster
111	Int_t fAccepted; // accept indicator
112	Double_t fRoad; // road defined by the cluster density
113	};
114
115
116	#endif