]>
Commit | Line | Data |
---|---|---|
3551db50 | 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 | /* $Id$ */ | |
17 | ||
18 | /////////////////////////////////////////////////////////////////////////////// | |
19 | // // | |
20 | // Class providing the calibration parameters by accessing the CDB // | |
21 | // // | |
22 | // Request an instance with AliTRDcalibDB::Instance() // | |
23 | // If a new event is processed set the event number with SetRun // | |
24 | // Then request the calibration data // | |
25 | // // | |
26 | /////////////////////////////////////////////////////////////////////////////// | |
27 | ||
28 | #include <TRandom.h> | |
29 | ||
30 | #include <AliCDBManager.h> | |
31 | ||
32 | #include "AliTRDcalibDB.h" | |
33 | #include "AliTRDgeometry.h" | |
34 | #include "AliTRDpadPlane.h" | |
35 | #include "AliTRDCommonParam.h" | |
36 | ||
37 | #include "AliTRDCalROC.h" | |
38 | #include "AliTRDCalChamber.h" | |
39 | #include "AliTRDCalStack.h" | |
40 | #include "AliTRDCalPad.h" | |
41 | #include "AliTRDCalDet.h" | |
42 | #include "AliTRDCalGlobals.h" | |
43 | ||
44 | ClassImp(AliTRDcalibDB) | |
45 | ||
46 | AliTRDcalibDB* AliTRDcalibDB::fgInstance = 0; | |
47 | Bool_t AliTRDcalibDB::fgTerminated = kFALSE; | |
48 | ||
49 | //_ singleton implementation __________________________________________________ | |
50 | AliTRDcalibDB* AliTRDcalibDB::Instance() | |
51 | { | |
52 | // | |
53 | // Singleton implementation | |
54 | // Returns an instance of this class, it is created if neccessary | |
55 | // | |
56 | ||
57 | if (fgTerminated != kFALSE) | |
58 | return 0; | |
59 | ||
60 | if (fgInstance == 0) | |
61 | fgInstance = new AliTRDcalibDB(); | |
62 | ||
63 | return fgInstance; | |
64 | } | |
65 | ||
66 | void AliTRDcalibDB::Terminate() | |
67 | { | |
68 | // | |
69 | // Singleton implementation | |
70 | // Deletes the instance of this class and sets the terminated flag, instances cannot be requested anymore | |
71 | // This function can be called several times. | |
72 | // | |
73 | ||
74 | fgTerminated = kTRUE; | |
75 | ||
76 | if (fgInstance != 0) | |
77 | { | |
78 | delete fgInstance; | |
79 | fgInstance = 0; | |
80 | } | |
81 | } | |
82 | ||
83 | //_____________________________________________________________________________ | |
84 | AliTRDcalibDB::AliTRDcalibDB() | |
85 | { | |
86 | // | |
87 | // constructor | |
88 | // | |
89 | ||
90 | fLocator = 0; | |
91 | // TODO Default runnumber is set to 0, this should be changed later to an invalid value (e.g. -1) to prevent | |
92 | // TODO invalid calibration data to be used. | |
93 | fRun = 0; | |
94 | ||
95 | AliCDBManager* manager = AliCDBManager::Instance(); | |
96 | if (!manager) | |
97 | { | |
98 | std::cout << "Failed to get instance of AliCDBManager." << std::endl; | |
99 | return; | |
100 | } | |
101 | ||
102 | fLocator = manager->GetStorage("local://$ALICE_ROOT"); | |
103 | ||
104 | for (Int_t i=0; i<kCDBCacheSize; ++i) | |
105 | { | |
106 | fCDBCache[i] = 0; | |
107 | fCDBEntries[i] = 0; | |
108 | } | |
109 | }; | |
110 | ||
111 | //_____________________________________________________________________________ | |
112 | AliTRDcalibDB::~AliTRDcalibDB() | |
113 | { | |
114 | // | |
115 | // destructor | |
116 | // | |
117 | ||
118 | Invalidate(); | |
119 | }; | |
120 | ||
121 | //_____________________________________________________________________________ | |
122 | void AliTRDcalibDB::SetRun(Long64_t run) | |
123 | { | |
124 | // | |
125 | // Sets current run number. Calibration data is read from the corresponding file. | |
126 | // When the run number changes the caching is invalidated. | |
127 | // | |
128 | ||
129 | if (fRun == run) | |
130 | return; | |
131 | ||
132 | fRun = run; | |
133 | Invalidate(); | |
134 | } | |
135 | ||
136 | //_____________________________________________________________________________ | |
137 | void AliTRDcalibDB::Invalidate() | |
138 | { | |
139 | // | |
140 | // Invalidates cache (when run number is changed). | |
141 | // | |
142 | ||
143 | for (Int_t i=0; i<kCDBCacheSize; ++i) | |
144 | { | |
145 | if (fCDBEntries[i]) | |
146 | { | |
dde59437 | 147 | if (fCDBEntries[i]->IsOwner() == kFALSE && fCDBCache[i]) |
3551db50 | 148 | delete fCDBCache[i]; |
dde59437 | 149 | |
3551db50 | 150 | delete fCDBEntries[i]; |
151 | fCDBEntries[i] = 0; | |
152 | fCDBCache[i] = 0; | |
153 | } | |
154 | } | |
155 | } | |
156 | ||
157 | //_____________________________________________________________________________ | |
158 | Bool_t AliTRDcalibDB::GetChamberPos(Int_t det, Float_t* xyz) | |
159 | { | |
160 | // | |
161 | // Returns the deviation of the chamber position from the nominal position. | |
162 | // | |
163 | ||
164 | AliTRDCalChamber* chamber = dynamic_cast<AliTRDCalChamber*>(GetCachedCDBObject(kIDChamber)); | |
165 | if (!chamber) | |
166 | return kFALSE; | |
167 | ||
168 | const Float_t* kvalues = chamber->GetChamberPos(det); | |
169 | if (!kvalues) | |
170 | return kFALSE; | |
171 | ||
172 | xyz[0] = kvalues[0]; | |
173 | xyz[1] = kvalues[1]; | |
174 | xyz[2] = kvalues[2]; | |
175 | ||
176 | return kTRUE; | |
177 | } | |
178 | ||
179 | //_____________________________________________________________________________ | |
180 | Bool_t AliTRDcalibDB::GetChamberRot(Int_t det, Float_t* xyz) | |
181 | { | |
182 | // | |
183 | // Returns the rotation of the chamber from the nominal position. | |
184 | // | |
185 | ||
186 | AliTRDCalChamber* chamber = dynamic_cast<AliTRDCalChamber*>(GetCachedCDBObject(kIDChamber)); | |
187 | if (!chamber) | |
188 | return kFALSE; | |
189 | ||
190 | const Float_t* kvalues = chamber->GetChamberRot(det); | |
191 | if (!kvalues) | |
192 | return kFALSE; | |
193 | ||
194 | xyz[0] = kvalues[0]; | |
195 | xyz[1] = kvalues[1]; | |
196 | xyz[2] = kvalues[2]; | |
197 | ||
198 | return kTRUE; | |
199 | } | |
200 | ||
201 | //_____________________________________________________________________________ | |
202 | Bool_t AliTRDcalibDB::GetStackPos(Int_t chamber, Int_t sector, Float_t* xyz) | |
203 | { | |
204 | // | |
205 | // Returns the deviation of the stack position from the nominal position. | |
206 | // | |
207 | ||
208 | AliTRDCalStack* stack = dynamic_cast<AliTRDCalStack*>(GetCachedCDBObject(kIDStack)); | |
209 | if (!stack) | |
210 | return kFALSE; | |
211 | ||
212 | const Float_t* kvalues = stack->GetStackPos(chamber, sector); | |
213 | if (!kvalues) | |
214 | return kFALSE; | |
215 | ||
216 | xyz[0] = kvalues[0]; | |
217 | xyz[1] = kvalues[1]; | |
218 | xyz[2] = kvalues[2]; | |
219 | ||
220 | return kTRUE; | |
221 | } | |
222 | ||
223 | //_____________________________________________________________________________ | |
224 | Bool_t AliTRDcalibDB::GetStackRot(Int_t chamber, Int_t sector, Float_t* xyz) | |
225 | { | |
226 | // | |
227 | // Returns the rotation of the stack from the nominal position. | |
228 | // | |
229 | ||
230 | AliTRDCalStack* stack = dynamic_cast<AliTRDCalStack*>(GetCachedCDBObject(kIDStack)); | |
231 | if (!stack) | |
232 | return kFALSE; | |
233 | ||
234 | const Float_t* kvalues = stack->GetStackRot(chamber, sector); | |
235 | if (!kvalues) | |
236 | return kFALSE; | |
237 | ||
238 | xyz[0] = kvalues[0]; | |
239 | xyz[1] = kvalues[1]; | |
240 | xyz[2] = kvalues[2]; | |
241 | ||
242 | return kTRUE; | |
243 | } | |
244 | ||
245 | //_____________________________________________________________________________ | |
246 | Float_t AliTRDcalibDB::GetVdrift(Int_t det, Int_t col, Int_t row) | |
247 | { | |
248 | // | |
249 | // Returns the drift velocity for the given pad. | |
250 | // | |
251 | ||
252 | AliTRDCalPad* calPad = dynamic_cast<AliTRDCalPad*> (GetCachedCDBObject(kIDVdrift)); | |
253 | if (!calPad) | |
254 | return -1; | |
255 | ||
256 | AliTRDCalROC* roc = calPad->GetCalROC(det); | |
257 | if (!roc) | |
258 | return -1; | |
259 | ||
260 | return roc->GetValue(col, row); | |
261 | }; | |
262 | ||
263 | //_____________________________________________________________________________ | |
264 | Float_t AliTRDcalibDB::GetT0(Int_t det, Int_t col, Int_t row) | |
265 | { | |
266 | // | |
267 | // Returns t0 for the given pad. | |
268 | // | |
269 | ||
270 | AliTRDCalPad* calPad = dynamic_cast<AliTRDCalPad*> (GetCachedCDBObject(kIDT0)); | |
271 | if (!calPad) | |
272 | return -1; | |
273 | ||
274 | AliTRDCalROC* roc = calPad->GetCalROC(det); | |
275 | if (!roc) | |
276 | return -1; | |
277 | ||
278 | return roc->GetValue(col, row); | |
279 | }; | |
280 | ||
281 | //_____________________________________________________________________________ | |
282 | Float_t AliTRDcalibDB::GetGainFactor(Int_t det, Int_t col, Int_t row) | |
283 | { | |
284 | // | |
285 | // Returns the gain factor for the given pad. | |
286 | // | |
287 | ||
288 | AliTRDCalPad* calPad = dynamic_cast<AliTRDCalPad*> (GetCachedCDBObject(kIDGainFactor)); | |
289 | if (!calPad) | |
290 | return -1; | |
291 | ||
292 | AliTRDCalROC* roc = calPad->GetCalROC(det); | |
293 | if (!roc) | |
294 | return -1; | |
295 | ||
296 | return roc->GetValue(col, row); | |
297 | }; | |
298 | ||
299 | //_____________________________________________________________________________ | |
300 | Float_t AliTRDcalibDB::GetSamplingFrequency() | |
301 | { | |
302 | // | |
303 | // Returns the sampling frequency of the TRD read-out. | |
304 | // | |
305 | ||
306 | AliTRDCalGlobals* calGlobal = dynamic_cast<AliTRDCalGlobals*> (GetCachedCDBObject(kIDGlobals)); | |
307 | if (!calGlobal) | |
308 | return -1; | |
309 | ||
310 | return calGlobal->GetSamplingFrequency(); | |
311 | } | |
312 | ||
313 | //_____________________________________________________________________________ | |
314 | Int_t AliTRDcalibDB::GetNumberOfTimeBins() | |
315 | { | |
316 | // | |
317 | // Returns the number of time bins which are read-out. | |
318 | // | |
319 | ||
320 | AliTRDCalGlobals* calGlobal = dynamic_cast<AliTRDCalGlobals*> (GetCachedCDBObject(kIDGlobals)); | |
321 | if (!calGlobal) | |
322 | return -1; | |
323 | ||
324 | return calGlobal->GetNumberOfTimeBins(); | |
325 | } | |
326 | ||
327 | //_____________________________________________________________________________ | |
328 | Float_t AliTRDcalibDB::GetOmegaTau(Float_t vdrift) | |
329 | { | |
330 | // | |
331 | // Returns omega*tau (tan(Lorentz-angle)) for a given drift velocity <vd> | |
332 | // and a B-field <b> for Xe/CO2 (15%). | |
333 | // The values are according to a GARFIELD simulation. | |
334 | // | |
335 | // This function basically does not belong to the calibration class. It should be moved somewhere else. | |
336 | // However, currently it is in use by simulation and reconstruction. | |
337 | // | |
338 | ||
339 | AliTRDCommonParam* commonParam = AliTRDCommonParam::Instance(); | |
340 | if (!commonParam) | |
341 | return -1; | |
342 | Float_t field = commonParam->GetField(); | |
343 | ||
344 | const Int_t kNb = 5; | |
345 | Float_t p0[kNb] = { 0.004810, 0.007412, 0.010252, 0.013409, 0.016888 }; | |
346 | Float_t p1[kNb] = { 0.054875, 0.081534, 0.107333, 0.131983, 0.155455 }; | |
347 | Float_t p2[kNb] = { -0.008682, -0.012896, -0.016987, -0.020880, -0.024623 }; | |
348 | Float_t p3[kNb] = { 0.000155, 0.000238, 0.000330, 0.000428, 0.000541 }; | |
349 | ||
350 | Int_t ib = ((Int_t) (10 * (field - 0.15))); | |
351 | ib = TMath::Max( 0,ib); | |
352 | ib = TMath::Min(kNb,ib); | |
353 | ||
354 | Float_t alphaL = p0[ib] | |
355 | + p1[ib] * vdrift | |
356 | + p2[ib] * vdrift*vdrift | |
357 | + p3[ib] * vdrift*vdrift*vdrift; | |
358 | ||
359 | return TMath::Tan(alphaL); | |
360 | } | |
361 |