]>
Commit | Line | Data |
---|---|---|
1 | /************************************************************************** | |
2 | * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * | |
3 | * * | |
4 | * Author: The ALICE Off-line Project. * | |
5 | * Contributors are mentioned in the code where appropriate. * | |
6 | * * | |
7 | * Permission to use, copy, modify and distribute this software and its * | |
8 | * documentation strictly for non-commercial purposes is hereby granted * | |
9 | * without fee, provided that the above copyright notice appears in all * | |
10 | * copies and that both the copyright notice and this permission notice * | |
11 | * appear in the supporting documentation. The authors make no claims * | |
12 | * about the suitability of this software for any purpose. It is * | |
13 | * provided "as is" without express or implied warranty. * | |
14 | **************************************************************************/ | |
15 | ||
16 | //------------------------------------------------------- | |
17 | // Implementation of the TPC transformation class | |
18 | // | |
19 | // Origin: Marian Ivanov Marian.Ivanov@cern.ch | |
20 | // Magnus Mager | |
21 | // | |
22 | // Class for tranformation of the coordinate frame | |
23 | // Transformation | |
24 | // local coordinate frame (sector, padrow, pad, timebine) ==> | |
25 | // rotated global (tracking) cooridnate frame (sector, lx,ly,lz) | |
26 | // | |
27 | // Unisochronity - (substract time0 - pad by pad) | |
28 | // Drift velocity - Currently common drift velocity - functionality of AliTPCParam | |
29 | // ExB effect - | |
30 | // | |
31 | // Time of flight correction - | |
32 | // - Depends on the vertex position | |
33 | // - by default | |
34 | // | |
35 | // Usage: | |
36 | // AliTPCclustererMI::AddCluster | |
37 | // AliTPCtrackerMI::Transform | |
38 | // | |
39 | //------------------------------------------------------- | |
40 | ||
41 | /* To test it: | |
42 | cdb=AliCDBManager::Instance() | |
43 | cdb->SetDefaultStorage("local:///u/mmager/mycalib1") | |
44 | c=AliTPCcalibDB::Instance() | |
45 | c->SetRun(0) | |
46 | Double_t x[]={1.0,2.0,3.0} | |
47 | Int_t i[]={4} | |
48 | AliTPCTransform trafo | |
49 | trafo.Transform(x,i,0,1) | |
50 | */ | |
51 | ||
52 | /* $Id$ */ | |
53 | ||
54 | #include "AliTPCROC.h" | |
55 | #include "AliTPCCalPad.h" | |
56 | #include "AliTPCCalROC.h" | |
57 | #include "AliTPCcalibDB.h" | |
58 | #include "AliTPCParam.h" | |
59 | #include "TMath.h" | |
60 | #include "AliLog.h" | |
61 | #include "AliTPCExB.h" | |
62 | #include "TGeoMatrix.h" | |
63 | #include "AliTPCRecoParam.h" | |
64 | #include "AliTPCCalibVdrift.h" | |
65 | #include "AliTPCTransform.h" | |
66 | ||
67 | ClassImp(AliTPCTransform) | |
68 | ||
69 | ||
70 | AliTPCTransform::AliTPCTransform(): | |
71 | AliTransform(), | |
72 | fCurrentRecoParam(0), //! current reconstruction parameters | |
73 | fCurrentRun(0), //! current run | |
74 | fCurrentTimeStamp(0) //! current time stamp | |
75 | { | |
76 | // | |
77 | // Speed it up a bit! | |
78 | // | |
79 | for (Int_t i=0;i<18;++i) { | |
80 | Double_t alpha=TMath::DegToRad()*(10.+20.*(i%18)); | |
81 | fSins[i]=TMath::Sin(alpha); | |
82 | fCoss[i]=TMath::Cos(alpha); | |
83 | } | |
84 | fPrimVtx[0]=0; | |
85 | fPrimVtx[1]=0; | |
86 | fPrimVtx[2]=0; | |
87 | } | |
88 | AliTPCTransform::AliTPCTransform(const AliTPCTransform& transform): | |
89 | AliTransform(transform), | |
90 | fCurrentRecoParam(transform.fCurrentRecoParam), //! current reconstruction parameters | |
91 | fCurrentRun(transform.fCurrentRun), //! current run | |
92 | fCurrentTimeStamp(transform.fCurrentTimeStamp) //! current time stamp | |
93 | { | |
94 | // | |
95 | // Speed it up a bit! | |
96 | // | |
97 | for (Int_t i=0;i<18;++i) { | |
98 | Double_t alpha=TMath::DegToRad()*(10.+20.*(i%18)); | |
99 | fSins[i]=TMath::Sin(alpha); | |
100 | fCoss[i]=TMath::Cos(alpha); | |
101 | } | |
102 | fPrimVtx[0]=0; | |
103 | fPrimVtx[1]=0; | |
104 | fPrimVtx[2]=0; | |
105 | } | |
106 | ||
107 | AliTPCTransform::~AliTPCTransform() { | |
108 | // | |
109 | // Destructor | |
110 | // | |
111 | } | |
112 | ||
113 | void AliTPCTransform::SetPrimVertex(Double_t *vtx){ | |
114 | // | |
115 | // | |
116 | // | |
117 | fPrimVtx[0]=vtx[0]; | |
118 | fPrimVtx[1]=vtx[1]; | |
119 | fPrimVtx[2]=vtx[2]; | |
120 | } | |
121 | ||
122 | ||
123 | void AliTPCTransform::Transform(Double_t *x,Int_t *i,UInt_t /*time*/, | |
124 | Int_t /*coordinateType*/) { | |
125 | // input: x[0] - pad row | |
126 | // x[1] - pad | |
127 | // x[2] - time in us | |
128 | // i[0] - sector | |
129 | // output: x[0] - x (all in the rotated global coordinate frame) | |
130 | // x[1] - y | |
131 | // x[2] - z | |
132 | // | |
133 | // primvtx - position of the primary vertex | |
134 | // used for the TOF correction | |
135 | // TOF of particle calculated assuming the speed-of-light and | |
136 | // line approximation | |
137 | // | |
138 | ||
139 | Int_t row=TMath::Nint(x[0]); | |
140 | Int_t pad=TMath::Nint(x[1]); | |
141 | Int_t sector=i[0]; | |
142 | AliTPCcalibDB* calib=AliTPCcalibDB::Instance(); | |
143 | // | |
144 | AliTPCCalPad * time0TPC = calib->GetPadTime0(); | |
145 | AliTPCParam * param = calib->GetParameters(); | |
146 | if (!time0TPC){ | |
147 | AliFatal("Time unisochronity missing"); | |
148 | } | |
149 | ||
150 | if (!param){ | |
151 | AliFatal("Parameters missing"); | |
152 | } | |
153 | ||
154 | Double_t xx[3]; | |
155 | // Apply Time0 correction - Pad by pad fluctuation | |
156 | // | |
157 | x[2]-=time0TPC->GetCalROC(sector)->GetValue(row,pad); | |
158 | // | |
159 | // Tranform from pad - time coordinate system to the rotated global (tracking) system | |
160 | // | |
161 | Local2RotatedGlobal(sector,x); | |
162 | // | |
163 | // | |
164 | // | |
165 | // Alignment | |
166 | //TODO: calib->GetParameters()->GetClusterMatrix(sector)->LocalToMaster(x,xx); | |
167 | RotatedGlobal2Global(sector,x); | |
168 | // | |
169 | // | |
170 | // ExB correction | |
171 | // | |
172 | if(fCurrentRecoParam&&fCurrentRecoParam->GetUseExBCorrection()) { | |
173 | ||
174 | calib->GetExB()->Correct(x,xx); | |
175 | ||
176 | } else { | |
177 | ||
178 | xx[0] = x[0]; | |
179 | xx[1] = x[1]; | |
180 | xx[2] = x[2]; | |
181 | } | |
182 | ||
183 | // | |
184 | // Time of flight correction | |
185 | // | |
186 | if (fCurrentRecoParam&&fCurrentRecoParam->GetUseTOFCorrection()){ | |
187 | const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector(); | |
188 | Float_t sign=1; | |
189 | if (sector < kNIS) { | |
190 | sign = (sector < kNIS/2) ? 1 : -1; | |
191 | } else { | |
192 | sign = ((sector-kNIS) < kNOS/2) ? 1 : -1; | |
193 | } | |
194 | Float_t deltaDr =0; | |
195 | Float_t dist=0; | |
196 | dist+=(fPrimVtx[0]-x[0])*(fPrimVtx[0]-x[0]); | |
197 | dist+=(fPrimVtx[1]-x[1])*(fPrimVtx[1]-x[1]); | |
198 | dist+=(fPrimVtx[2]-x[2])*(fPrimVtx[2]-x[2]); | |
199 | dist = TMath::Sqrt(dist); | |
200 | // drift length correction because of TOF | |
201 | // the drift velocity is in cm/s therefore multiplication by 0.01 | |
202 | deltaDr = (dist*(0.01*param->GetDriftV()))/TMath::C(); | |
203 | xx[2]+=sign*deltaDr; | |
204 | } | |
205 | // | |
206 | // | |
207 | // | |
208 | ||
209 | // | |
210 | Global2RotatedGlobal(sector,xx); | |
211 | // | |
212 | x[0]=xx[0];x[1]=xx[1];x[2]=xx[2]; | |
213 | } | |
214 | ||
215 | void AliTPCTransform::Local2RotatedGlobal(Int_t sector, Double_t *x) const { | |
216 | // | |
217 | // | |
218 | // Tranform coordinate from | |
219 | // row, pad, time to x,y,z | |
220 | // | |
221 | // Drift Velocity | |
222 | // Current implementation - common drift velocity - for full chamber | |
223 | // TODO: use a map or parametrisation! | |
224 | // | |
225 | // | |
226 | // | |
227 | const Int_t kMax =60; // cache for 60 seconds | |
228 | static Int_t lastStamp=-1; //cached values | |
229 | static Double_t lastCorr = 1; | |
230 | // | |
231 | AliTPCcalibDB* calib=AliTPCcalibDB::Instance(); | |
232 | AliTPCParam * param = calib->GetParameters(); | |
233 | AliTPCCalibVdrift *driftCalib = AliTPCcalibDB::Instance()->GetVdrift(fCurrentRun); | |
234 | Double_t driftCorr = 1.; | |
235 | if (driftCalib){ | |
236 | // | |
237 | // caching drift correction - temp. fix | |
238 | // Extremally slow procedure | |
239 | if ( TMath::Abs((lastStamp)-Int_t(fCurrentTimeStamp))<kMax){ | |
240 | driftCorr = lastCorr; | |
241 | }else{ | |
242 | driftCorr = 1.+(driftCalib->GetPTRelative(fCurrentTimeStamp,0)+ driftCalib->GetPTRelative(fCurrentTimeStamp,1))*0.5; | |
243 | lastCorr=driftCorr; | |
244 | lastStamp=fCurrentTimeStamp; | |
245 | ||
246 | } | |
247 | } | |
248 | // | |
249 | // simple caching non thread save | |
250 | static Double_t vdcorrectionTime=1; | |
251 | static Double_t time0corrTime=0; | |
252 | static Int_t lastStampT=-1; | |
253 | // | |
254 | if (lastStampT!=(Int_t)fCurrentTimeStamp){ | |
255 | lastStampT=fCurrentTimeStamp; | |
256 | if(fCurrentRecoParam&&fCurrentRecoParam->GetUseDriftCorrectionTime()>0) { | |
257 | vdcorrectionTime = (1+AliTPCcalibDB::Instance()-> | |
258 | GetVDriftCorrectionTime(fCurrentTimeStamp, | |
259 | AliTPCcalibDB::Instance()->GetRun(), | |
260 | sector%36>=18, | |
261 | fCurrentRecoParam->GetUseDriftCorrectionTime())); | |
262 | time0corrTime= AliTPCcalibDB::Instance()-> | |
263 | GetTime0CorrectionTime(fCurrentTimeStamp, | |
264 | AliTPCcalibDB::Instance()->GetRun(), | |
265 | sector%36>=18, | |
266 | fCurrentRecoParam->GetUseDriftCorrectionTime()); | |
267 | } | |
268 | // | |
269 | if(fCurrentRecoParam&&fCurrentRecoParam->GetUseDriftCorrectionGY()>0) { | |
270 | Float_t xyzPad[3]; | |
271 | AliTPCROC::Instance()->GetPositionGlobal(sector, TMath::Nint(x[0]) ,TMath::Nint(x[1]), xyzPad); | |
272 | ||
273 | Double_t corrGy= (1+(xyzPad[1])*AliTPCcalibDB::Instance()-> | |
274 | GetVDriftCorrectionGy(fCurrentTimeStamp, | |
275 | AliTPCcalibDB::Instance()->GetRun(), | |
276 | sector%36>=18, | |
277 | fCurrentRecoParam->GetUseDriftCorrectionGY())); | |
278 | vdcorrectionTime *=corrGy; | |
279 | } | |
280 | } | |
281 | ||
282 | ||
283 | if (!param){ | |
284 | AliFatal("Parameters missing"); | |
285 | } | |
286 | Int_t row=TMath::Nint(x[0]); | |
287 | // Int_t pad=TMath::Nint(x[1]); | |
288 | // | |
289 | const Int_t kNIS=param->GetNInnerSector(), kNOS=param->GetNOuterSector(); | |
290 | Double_t sign = 1.; | |
291 | Double_t zwidth = param->GetZWidth()*driftCorr*vdcorrectionTime; | |
292 | Double_t padWidth = 0; | |
293 | Double_t padLength = 0; | |
294 | Double_t maxPad = 0; | |
295 | // | |
296 | if (sector < kNIS) { | |
297 | maxPad = param->GetNPadsLow(row); | |
298 | sign = (sector < kNIS/2) ? 1 : -1; | |
299 | padLength = param->GetPadPitchLength(sector,row); | |
300 | padWidth = param->GetPadPitchWidth(sector); | |
301 | } else { | |
302 | maxPad = param->GetNPadsUp(row); | |
303 | sign = ((sector-kNIS) < kNOS/2) ? 1 : -1; | |
304 | padLength = param->GetPadPitchLength(sector,row); | |
305 | padWidth = param->GetPadPitchWidth(sector); | |
306 | } | |
307 | // | |
308 | // X coordinate | |
309 | x[0] = param->GetPadRowRadii(sector,row); // padrow X position - ideal | |
310 | // | |
311 | // Y coordinate | |
312 | // | |
313 | x[1]=(x[1]-0.5*maxPad)*padWidth; | |
314 | // pads are mirrorred on C-side | |
315 | if (sector%36>17){ | |
316 | x[1]*=-1; | |
317 | } | |
318 | ||
319 | // | |
320 | ||
321 | // | |
322 | // Z coordinate | |
323 | // | |
324 | x[2]*= zwidth; // tranform time bin to the distance to the ROC | |
325 | x[2]-= 3.*param->GetZSigma() + param->GetNTBinsL1()*zwidth+ time0corrTime; | |
326 | // subtract the time offsets | |
327 | x[2] = sign*( param->GetZLength(sector) - x[2]); | |
328 | } | |
329 | ||
330 | void AliTPCTransform::RotatedGlobal2Global(Int_t sector,Double_t *x) const { | |
331 | // | |
332 | // transform possition rotated global to the global | |
333 | // | |
334 | Double_t cos,sin; | |
335 | GetCosAndSin(sector,cos,sin); | |
336 | Double_t tmp=x[0]; | |
337 | x[0]= cos*tmp-sin*x[1]; | |
338 | x[1]=+sin*tmp+cos*x[1]; | |
339 | } | |
340 | ||
341 | void AliTPCTransform::Global2RotatedGlobal(Int_t sector,Double_t *x) const { | |
342 | // | |
343 | // tranform possition Global2RotatedGlobal | |
344 | // | |
345 | Double_t cos,sin; | |
346 | GetCosAndSin(sector,cos,sin); | |
347 | Double_t tmp=x[0]; | |
348 | x[0]= cos*tmp+sin*x[1]; | |
349 | x[1]= -sin*tmp+cos*x[1]; | |
350 | } | |
351 | ||
352 | void AliTPCTransform::GetCosAndSin(Int_t sector,Double_t &cos, | |
353 | Double_t &sin) const { | |
354 | cos=fCoss[sector%18]; | |
355 | sin=fSins[sector%18]; | |
356 | } | |
357 | ||
358 | ||
359 | void AliTPCTransform::ApplyTransformations(Double_t */*xyz*/, Int_t /*volID*/){ | |
360 | // | |
361 | // Modify global position | |
362 | // xyz - global xyz position | |
363 | // volID - volID of detector (sector number) | |
364 | // | |
365 | // | |
366 | ||
367 | } |