]>
Commit | Line | Data |
---|---|---|
1 | //-*- Mode: C++ -*- | |
2 | // @(#) $Id$ | |
3 | // ************************************************************************ | |
4 | // This file is property of and copyright by the ALICE HLT Project * | |
5 | // ALICE Experiment at CERN, All rights reserved. * | |
6 | // See cxx source for full Copyright notice * | |
7 | // * | |
8 | //************************************************************************* | |
9 | ||
10 | #ifndef ALIHLTTPCCAPARAM_H | |
11 | #define ALIHLTTPCCAPARAM_H | |
12 | ||
13 | #include "AliHLTTPCCADef.h" | |
14 | #include "AliHLTTPCCAMath.h" | |
15 | #include "AliHLTTPCCATrackParam.h" | |
16 | ||
17 | #include <iostream> | |
18 | ||
19 | ||
20 | /** | |
21 | * @class ALIHLTTPCCAParam | |
22 | * parameters of the AliHLTTPCCATracker, including geometry information | |
23 | * and some reconstructon constants. | |
24 | * | |
25 | * The class is under construction. | |
26 | * | |
27 | */ | |
28 | class AliHLTTPCCAParam | |
29 | { | |
30 | public: | |
31 | AliHLTTPCCAParam(); | |
32 | ~AliHLTTPCCAParam() {} | |
33 | ||
34 | #if !defined(HLTCA_GPUCODE) | |
35 | void Initialize( int iSlice, int nRows, float rowX[], | |
36 | float alpha, float dAlpha, | |
37 | float rMin, float rMax, float zMin, float zMax, | |
38 | float padPitch, float zSigma, float bz ); | |
39 | void Update(); | |
40 | #endif //!HLTCA_GPUCODE | |
41 | ||
42 | GPUd() void Slice2Global( float x, float y, float z, | |
43 | float *X, float *Y, float *Z ) const; | |
44 | ||
45 | GPUd() void Global2Slice( float x, float y, float z, | |
46 | float *X, float *Y, float *Z ) const; | |
47 | ||
48 | ||
49 | GPUhd() int ISlice() const { return fISlice;} | |
50 | GPUhd() int NRows() const { return fNRows;} | |
51 | ||
52 | GPUhd() float RowX( int iRow ) const { return fRowX[iRow]; } | |
53 | ||
54 | GPUd() float Alpha() const { return fAlpha;} | |
55 | GPUd() float Alpha( int iSlice ) const { return 0.174533 + DAlpha()*iSlice;} | |
56 | GPUd() float DAlpha() const { return fDAlpha;} | |
57 | GPUd() float CosAlpha() const { return fCosAlpha;} | |
58 | GPUd() float SinAlpha() const { return fSinAlpha;} | |
59 | GPUd() float AngleMin() const { return fAngleMin;} | |
60 | GPUd() float AngleMax() const { return fAngleMax;} | |
61 | GPUd() float RMin() const { return fRMin;} | |
62 | GPUd() float RMax() const { return fRMax;} | |
63 | GPUd() float ZMin() const { return fZMin;} | |
64 | GPUd() float ZMax() const { return fZMax;} | |
65 | GPUd() float ErrZ() const { return fErrZ;} | |
66 | GPUd() float ErrX() const { return fErrX;} | |
67 | GPUd() float ErrY() const { return fErrY;} | |
68 | GPUd() float BzkG() const { return fBzkG;} | |
69 | GPUd() float ConstBz() const { return fConstBz;} | |
70 | ||
71 | GPUd() float NeighboursSearchArea() const { return fNeighboursSearchArea; } | |
72 | GPUd() float TrackConnectionFactor() const { return fTrackConnectionFactor; } | |
73 | GPUd() float TrackChiCut() const { return fTrackChiCut; } | |
74 | GPUd() float TrackChi2Cut() const { return fTrackChi2Cut; } | |
75 | GPUd() int MaxTrackMatchDRow() const { return fMaxTrackMatchDRow; } | |
76 | GPUd() float HitPickUpFactor() const { return fHitPickUpFactor; } | |
77 | GPUd() float ClusterError2CorrectionY() const { return fClusterError2CorrectionY; } | |
78 | GPUd() float ClusterError2CorrectionZ() const { return fClusterError2CorrectionZ; } | |
79 | ||
80 | ||
81 | ||
82 | GPUhd() void SetISlice( int v ) { fISlice = v;} | |
83 | GPUhd() void SetNRows( int v ) { fNRows = v;} | |
84 | GPUhd() void SetRowX( int iRow, float v ) { fRowX[iRow] = v; } | |
85 | GPUd() void SetAlpha( float v ) { fAlpha = v;} | |
86 | GPUd() void SetDAlpha( float v ) { fDAlpha = v;} | |
87 | GPUd() void SetCosAlpha( float v ) { fCosAlpha = v;} | |
88 | GPUd() void SetSinAlpha( float v ) { fSinAlpha = v;} | |
89 | GPUd() void SetAngleMin( float v ) { fAngleMin = v;} | |
90 | GPUd() void SetAngleMax( float v ) { fAngleMax = v;} | |
91 | GPUd() void SetRMin( float v ) { fRMin = v;} | |
92 | GPUd() void SetRMax( float v ) { fRMax = v;} | |
93 | GPUd() void SetZMin( float v ) { fZMin = v;} | |
94 | GPUd() void SetZMax( float v ) { fZMax = v;} | |
95 | GPUd() void SetErrZ( float v ) { fErrZ = v;} | |
96 | GPUd() void SetErrX( float v ) { fErrX = v;} | |
97 | GPUd() void SetErrY( float v ) { fErrY = v;} | |
98 | GPUd() void SetBzkG( float v ) { fBzkG = v;} | |
99 | ||
100 | GPUd() void SetNeighboursSearchArea( float v ) { fNeighboursSearchArea = v;} | |
101 | GPUd() void SetTrackConnectionFactor( float v ) { fTrackConnectionFactor = v;} | |
102 | GPUd() void SetTrackChiCut( float v ) { fTrackChiCut = v; } | |
103 | GPUd() void SetTrackChi2Cut( float v ) { fTrackChi2Cut = v; } | |
104 | GPUd() void SetMaxTrackMatchDRow( int v ) { fMaxTrackMatchDRow = v; } | |
105 | GPUd() void SetHitPickUpFactor( float v ) { fHitPickUpFactor = v; } | |
106 | GPUd() void SetClusterError2CorrectionY( float v ) { fClusterError2CorrectionY = v; } | |
107 | GPUd() void SetClusterError2CorrectionZ( float v ) { fClusterError2CorrectionZ = v; } | |
108 | ||
109 | ||
110 | GPUd() float GetClusterError2( int yz, int type, float z, float angle ) const; | |
111 | GPUd() void GetClusterErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const; | |
112 | ||
113 | void WriteSettings( std::ostream &out ) const; | |
114 | void ReadSettings( std::istream &in ); | |
115 | ||
116 | GPUd() void SetParamS0Par( int i, int j, int k, float val ) { | |
117 | fParamS0Par[i][j][k] = val; | |
118 | } | |
119 | ||
120 | GPUd() float GetBzkG() const { return fBzkG;} | |
121 | GPUd() float GetConstBz() const { return fConstBz;} | |
122 | GPUd() float GetBz( float x, float y, float z ) const; | |
123 | GPUd() float GetBz( const AliHLTTPCCATrackParam &t ) const; | |
124 | ||
125 | protected: | |
126 | int fISlice; // slice number | |
127 | int fNRows; // number of rows | |
128 | ||
129 | float fAlpha, fDAlpha; // slice angle and angular size | |
130 | float fCosAlpha, fSinAlpha;// sign and cosine of the slice angle | |
131 | float fAngleMin, fAngleMax; // minimal and maximal angle | |
132 | float fRMin, fRMax;// slice R range | |
133 | float fZMin, fZMax;// slice Z range | |
134 | float fErrX, fErrY, fErrZ;// default cluster errors | |
135 | float fPadPitch; // pad pitch | |
136 | float fBzkG; // constant magnetic field value in kG | |
137 | float fConstBz; // constant magnetic field value in kG*clight | |
138 | ||
139 | float fHitPickUpFactor;// multiplier for the chi2 window for hit pick up procedure | |
140 | ||
141 | int fMaxTrackMatchDRow;// maximal jump in TPC row for connecting track segments | |
142 | ||
143 | float fNeighboursSearchArea; // area in cm for the search of neighbours | |
144 | ||
145 | float fTrackConnectionFactor; // allowed distance in Chi^2/3.5 for neighbouring tracks | |
146 | float fTrackChiCut; // cut for track Sqrt(Chi2/NDF); | |
147 | float fTrackChi2Cut;// cut for track Chi^2/NDF | |
148 | float fClusterError2CorrectionY; // correction for the squared cluster error during tracking | |
149 | float fClusterError2CorrectionZ; // correction for the squared cluster error during tracking | |
150 | float fRowX[200];// X-coordinate of rows | |
151 | float fParamS0Par[2][3][7]; // cluster error parameterization coeficients | |
152 | float fPolinomialFieldBz[6]; // field coefficients | |
153 | ||
154 | }; | |
155 | ||
156 | ||
157 | ||
158 | GPUd() inline float AliHLTTPCCAParam::GetBz( float x, float y, float z ) const | |
159 | { | |
160 | float r2 = x * x + y * y; | |
161 | float r = CAMath::Sqrt( r2 ); | |
162 | const float *c = fPolinomialFieldBz; | |
163 | return ( c[0] + c[1]*z + c[2]*r + c[3]*z*z + c[4]*z*r + c[5]*r2 ); | |
164 | } | |
165 | ||
166 | GPUd() inline float AliHLTTPCCAParam::GetBz( const AliHLTTPCCATrackParam &t ) const | |
167 | { | |
168 | return GetBz( t.X(), t.Y(), t.Z() ); | |
169 | } | |
170 | ||
171 | #endif //ALIHLTTPCCAPARAM_H |