]>
Commit | Line | Data |
---|---|---|
55a288e5 | 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 | ||
0bc7827a | 18 | //////////////////////////////////////////////////////////////////////////// |
19 | // // | |
20 | // AliTRDCalibraVector // | |
21 | // // | |
22 | // This class is for the vector method of the TRD calibration. // | |
23 | // // | |
24 | // Author: // | |
25 | // R. Bailhache (R.Bailhache@gsi.de) // | |
26 | // // | |
27 | //////////////////////////////////////////////////////////////////////////// | |
55a288e5 | 28 | |
29 | #include <TGraphErrors.h> | |
30 | #include <TH1F.h> | |
55a288e5 | 31 | #include <TObjArray.h> |
32 | #include <TMath.h> | |
55a288e5 | 33 | #include <TDirectory.h> |
34 | #include <TROOT.h> | |
35 | #include <TFile.h> | |
36 | ||
37 | #include "AliLog.h" | |
38 | ||
39 | #include "AliTRDCalibraVector.h" | |
40 | #include "AliTRDCommonParam.h" | |
3a0f6479 | 41 | #include "AliTRDarrayF.h" |
42 | #include "AliTRDarrayI.h" | |
55a288e5 | 43 | |
44 | ClassImp(AliTRDCalibraVector) | |
45 | ||
46 | //______________________________________________________________________________________ | |
47 | AliTRDCalibraVector::AliTRDCalibraVector() | |
48 | :TObject() | |
3a0f6479 | 49 | ,fPHEntries(0x0) |
50 | ,fPHMean(0x0) | |
51 | ,fPHSquares(0x0) | |
52 | ,fPRFEntries(0x0) | |
53 | ,fPRFMean(0x0) | |
54 | ,fPRFSquares(0x0) | |
55 | ,fCHEntries(0x0) | |
56 | ,fDetectorPH(-1) | |
57 | ,fDetectorCH(-1) | |
58 | ,fDetectorPRF(-1) | |
59 | ,fVectorPHMean(540) | |
60 | ,fVectorPHSquares(540) | |
61 | ,fVectorPHEntries(540) | |
62 | ,fVectorCHEntries(540) | |
63 | ,fVectorPRFMean(540) | |
64 | ,fVectorPRFSquares(540) | |
65 | ,fVectorPRFEntries(540) | |
55a288e5 | 66 | ,fNumberBinCharge(0) |
67 | ,fNumberBinPRF(0) | |
68 | ,fTimeMax(0) | |
170c35f1 | 69 | ,fPRFRange(1.5) |
55a288e5 | 70 | { |
71 | // | |
72 | // Default constructor | |
73 | // | |
3a0f6479 | 74 | |
75 | for(Int_t k = 0; k < 3; k++){ | |
76 | fDetCha0[k] = 0; | |
77 | fDetCha2[k] = 0; | |
78 | } | |
79 | ||
55a288e5 | 80 | } |
55a288e5 | 81 | //______________________________________________________________________________________ |
82 | AliTRDCalibraVector::AliTRDCalibraVector(const AliTRDCalibraVector &c) | |
83 | :TObject(c) | |
3a0f6479 | 84 | ,fPHEntries(0x0) |
85 | ,fPHMean(0x0) | |
86 | ,fPHSquares(0x0) | |
87 | ,fPRFEntries(0x0) | |
88 | ,fPRFMean(0x0) | |
89 | ,fPRFSquares(0x0) | |
90 | ,fCHEntries(0x0) | |
91 | ,fDetectorPH(-1) | |
92 | ,fDetectorCH(-1) | |
93 | ,fDetectorPRF(-1) | |
94 | ,fVectorPHMean(540) | |
95 | ,fVectorPHSquares(540) | |
96 | ,fVectorPHEntries(540) | |
97 | ,fVectorCHEntries(540) | |
98 | ,fVectorPRFMean(540) | |
99 | ,fVectorPRFSquares(540) | |
100 | ,fVectorPRFEntries(540) | |
170c35f1 | 101 | ,fNumberBinCharge(c.fNumberBinCharge) |
102 | ,fNumberBinPRF(c.fNumberBinPRF) | |
103 | ,fTimeMax(c.fTimeMax) | |
104 | ,fPRFRange(c.fPRFRange) | |
55a288e5 | 105 | { |
106 | // | |
107 | // Copy constructor | |
108 | // | |
3a0f6479 | 109 | for (Int_t idet = 0; idet < 540; idet++){ |
110 | ||
111 | const AliTRDarrayI *phEntries = (AliTRDarrayI*)c.fVectorPHEntries.UncheckedAt(idet); | |
112 | const AliTRDarrayF *phMean = (AliTRDarrayF*)c.fVectorPHMean.UncheckedAt(idet); | |
113 | const AliTRDarrayF *phSquares = (AliTRDarrayF*)c.fVectorPHSquares.UncheckedAt(idet); | |
114 | ||
115 | const AliTRDarrayI *prfEntries = (AliTRDarrayI*)c.fVectorPRFEntries.UncheckedAt(idet); | |
116 | const AliTRDarrayF *prfMean = (AliTRDarrayF*)c.fVectorPRFMean.UncheckedAt(idet); | |
117 | const AliTRDarrayF *prfSquares = (AliTRDarrayF*)c.fVectorPRFSquares.UncheckedAt(idet); | |
118 | ||
119 | const AliTRDarrayI *chEntries = (AliTRDarrayI*)c.fVectorCHEntries.UncheckedAt(idet); | |
55a288e5 | 120 | |
3a0f6479 | 121 | if ( phEntries != 0x0 ) fVectorPHEntries.AddAt(new AliTRDarrayI(*phEntries), idet); |
122 | if ( phMean != 0x0 ) fVectorPHMean.AddAt(new AliTRDarrayF(*phMean), idet); | |
123 | if ( phSquares != 0x0 ) fVectorPHSquares.AddAt(new AliTRDarrayF(*phSquares), idet); | |
124 | ||
125 | if ( prfEntries != 0x0 ) fVectorPRFEntries.AddAt(new AliTRDarrayI(*prfEntries), idet); | |
126 | if ( prfMean != 0x0 ) fVectorPRFMean.AddAt(new AliTRDarrayF(*prfMean), idet); | |
127 | if ( prfSquares != 0x0 ) fVectorPRFSquares.AddAt(new AliTRDarrayF(*prfSquares), idet); | |
128 | ||
129 | ||
130 | if ( chEntries != 0x0 ) fVectorCHEntries.AddAt(new AliTRDarrayI(*chEntries), idet); | |
131 | ||
132 | } | |
133 | ||
134 | for(Int_t k = 0; k < 3; k++){ | |
135 | fDetCha0[k] = c.fDetCha0[k]; | |
136 | fDetCha2[k] = c.fDetCha2[k]; | |
137 | } | |
138 | ||
139 | fVectorPHEntries.SetName(c.fVectorPHEntries.GetName()); | |
140 | fVectorCHEntries.SetName(c.fVectorCHEntries.GetName()); | |
141 | fVectorPRFEntries.SetName(c.fVectorPRFEntries.GetName()); | |
142 | ||
143 | } | |
144 | //_____________________________________________________________________ | |
145 | AliTRDCalibraVector& AliTRDCalibraVector::operator = (const AliTRDCalibraVector &source) | |
146 | { | |
147 | // | |
148 | // assignment operator | |
149 | // | |
150 | if (&source == this) return *this; | |
151 | new (this) AliTRDCalibraVector(source); | |
152 | ||
153 | return *this; | |
55a288e5 | 154 | } |
55a288e5 | 155 | //____________________________________________________________________________________ |
156 | AliTRDCalibraVector::~AliTRDCalibraVector() | |
157 | { | |
158 | // | |
159 | // AliTRDCalibraVector destructor | |
160 | // | |
1ca79a00 | 161 | fVectorPHMean.Delete(); |
162 | fVectorPHSquares.Delete(); | |
163 | fVectorPHEntries.Delete(); | |
164 | fVectorCHEntries.Delete(); | |
165 | fVectorPRFMean.Delete(); | |
166 | fVectorPRFSquares.Delete(); | |
167 | fVectorPRFEntries.Delete(); | |
168 | ||
169 | if(fPHEntries) delete fPHEntries; | |
170 | if(fPHMean) delete fPHMean; | |
171 | if(fPHSquares) delete fPHSquares; | |
172 | if(fPRFEntries) delete fPRFEntries; | |
173 | if(fPRFMean) delete fPRFMean; | |
174 | if(fPRFSquares) delete fPRFSquares; | |
175 | if(fCHEntries) delete fCHEntries; | |
55a288e5 | 176 | |
177 | } | |
55a288e5 | 178 | //_____________________________________________________________________________ |
179 | Int_t AliTRDCalibraVector::SearchBin(Float_t value, Int_t i) const | |
180 | { | |
181 | // | |
182 | // Search the bin | |
183 | // | |
184 | ||
170c35f1 | 185 | Int_t reponse = 0; |
186 | Float_t fbinmin = 0; | |
187 | Float_t fbinmax = value; | |
188 | Int_t fNumberOfBin = -1; | |
55a288e5 | 189 | |
3a0f6479 | 190 | switch(i) |
191 | { | |
192 | case 0: | |
193 | fbinmax = 300.0; | |
194 | fbinmin = 0.0; | |
195 | fNumberOfBin = fNumberBinCharge; | |
196 | break; | |
197 | ||
198 | case 2: | |
199 | fbinmax = TMath::Abs(fPRFRange); | |
200 | fbinmin = -TMath::Abs(fPRFRange); | |
201 | fNumberOfBin = fNumberBinPRF; | |
202 | break; | |
203 | ||
204 | default: | |
205 | return -1; | |
206 | } | |
207 | ||
55a288e5 | 208 | // Return -1 if out |
209 | if ((value >= fbinmax) || | |
210 | (value < fbinmin)) { | |
211 | return -1; | |
212 | } | |
55a288e5 | 213 | else { |
214 | reponse = (Int_t) ((fNumberOfBin*(value-fbinmin)) / (fbinmax-fbinmin)); | |
215 | } | |
216 | ||
217 | return reponse; | |
218 | ||
219 | } | |
55a288e5 | 220 | //_____________________________________________________________________________ |
3a0f6479 | 221 | Bool_t AliTRDCalibraVector::UpdateVectorCH(Int_t det, Int_t group, Float_t value) |
55a288e5 | 222 | { |
223 | // | |
3a0f6479 | 224 | // Fill the vector CH |
55a288e5 | 225 | // |
226 | ||
227 | // Search bin | |
228 | Int_t bin = SearchBin(value,0); | |
229 | // Out | |
3a0f6479 | 230 | if (bin == -1) { |
55a288e5 | 231 | return kFALSE; |
232 | } | |
233 | ||
3a0f6479 | 234 | |
235 | ||
236 | if(fDetectorCH != det){ | |
237 | fCHEntries = ((AliTRDarrayI *)GetCHEntries(det,kTRUE)); | |
55a288e5 | 238 | } |
239 | ||
3a0f6479 | 240 | Int_t entries = fCHEntries->At(group*fNumberBinCharge+bin); |
241 | ||
242 | Int_t entriesn = entries+1; | |
243 | fCHEntries->AddAt(entriesn,group*fNumberBinCharge+bin); | |
244 | ||
245 | fDetectorCH = det; | |
246 | ||
247 | ||
55a288e5 | 248 | return kTRUE; |
249 | ||
250 | } | |
55a288e5 | 251 | //_____________________________________________________________________________ |
3a0f6479 | 252 | Bool_t AliTRDCalibraVector::UpdateVectorPRF(Int_t det, Int_t group, Float_t x, Float_t y) |
55a288e5 | 253 | { |
254 | // | |
3a0f6479 | 255 | // Fill the vector PRF |
55a288e5 | 256 | // |
257 | ||
258 | // Search bin | |
259 | Int_t bin = SearchBin(x,2); | |
260 | // Out | |
3a0f6479 | 261 | if (bin == -1) { |
55a288e5 | 262 | return kFALSE; |
263 | } | |
264 | ||
3a0f6479 | 265 | |
266 | if(fDetectorPRF != det){ | |
267 | fPRFEntries = ((AliTRDarrayI *)GetPRFEntries(det,kTRUE)); | |
268 | fPRFMean = ((AliTRDarrayF *)GetPRFMean(det,kTRUE)); | |
269 | fPRFSquares = ((AliTRDarrayF *)GetPRFSquares(det,kTRUE)); | |
55a288e5 | 270 | } |
55a288e5 | 271 | |
3a0f6479 | 272 | Int_t entries = fPRFEntries->At(group*fNumberBinPRF+bin); |
273 | Float_t mean = fPRFMean->At(group*fNumberBinPRF+bin); | |
274 | Float_t square = fPRFSquares->At(group*fNumberBinPRF+bin); | |
275 | ||
276 | Int_t entriesn = entries+1; | |
277 | fPRFEntries->AddAt(entriesn,group*fNumberBinPRF+bin); | |
278 | Float_t meann = (mean*((Float_t)entries)+y)/((Float_t)entriesn); | |
279 | fPRFMean->AddAt(meann,group*fNumberBinPRF+bin); | |
280 | Float_t squaren = ((square*((Float_t)entries))+(y*y))/((Float_t)entriesn); | |
281 | fPRFSquares->AddAt(squaren,group*fNumberBinPRF+bin); | |
55a288e5 | 282 | |
3a0f6479 | 283 | |
284 | fDetectorPRF = det; | |
55a288e5 | 285 | |
286 | return kTRUE; | |
3a0f6479 | 287 | |
55a288e5 | 288 | } |
55a288e5 | 289 | //_____________________________________________________________________________ |
3a0f6479 | 290 | Bool_t AliTRDCalibraVector::UpdateVectorPH(Int_t det, Int_t group, Int_t time, Float_t value) |
55a288e5 | 291 | { |
292 | // | |
3a0f6479 | 293 | // Fill the vector PH |
55a288e5 | 294 | // |
295 | ||
296 | // Search bin | |
297 | Int_t bin = time; | |
298 | // Out | |
299 | if ((bin < 0) || | |
300 | (bin >= fTimeMax)) { | |
301 | return kFALSE; | |
302 | } | |
303 | ||
55a288e5 | 304 | |
3a0f6479 | 305 | if(fDetectorPH != det){ |
306 | fPHEntries = ((AliTRDarrayI *)GetPHEntries(det,kTRUE)); | |
307 | fPHMean = ((AliTRDarrayF *)GetPHMean(det,kTRUE)); | |
308 | fPHSquares = ((AliTRDarrayF *)GetPHSquares(det,kTRUE)); | |
309 | } | |
55a288e5 | 310 | |
3a0f6479 | 311 | Int_t entries = fPHEntries->At(group*fTimeMax+bin); |
312 | Float_t mean = fPHMean->At(group*fTimeMax+bin); | |
313 | Float_t square = fPHSquares->At(group*fTimeMax+bin); | |
314 | ||
315 | Int_t entriesn = entries+1; | |
316 | fPHEntries->AddAt(entriesn,group*fTimeMax+bin); | |
317 | Float_t meann = (mean*((Float_t)entries)+value)/((Float_t)entriesn); | |
318 | fPHMean->AddAt(meann,group*fTimeMax+bin); | |
319 | Float_t squaren = ((square*((Float_t)entries))+(value*value))/((Float_t)entriesn); | |
320 | fPHSquares->AddAt(squaren,group*fTimeMax+bin); | |
55a288e5 | 321 | |
3a0f6479 | 322 | |
323 | fDetectorPH = det; | |
55a288e5 | 324 | |
3a0f6479 | 325 | return kTRUE; |
326 | ||
327 | } | |
328 | //__________________________________________________________________________________ | |
329 | Bool_t AliTRDCalibraVector::Add(AliTRDCalibraVector *calvect) | |
330 | { | |
331 | // | |
332 | // Add a other AliTRCalibraVector to this one | |
333 | // | |
55a288e5 | 334 | |
3a0f6479 | 335 | // Check compatibility |
336 | if(fNumberBinCharge != calvect->GetNumberBinCharge()) return kFALSE; | |
337 | if(fNumberBinPRF != calvect->GetNumberBinPRF()) return kFALSE; | |
338 | if(fPRFRange != calvect->GetPRFRange()) return kFALSE; | |
339 | if(fTimeMax != calvect->GetTimeMax()) return kFALSE; | |
340 | for(Int_t k = 0; k < 3; k++){ | |
341 | if(fDetCha0[k] != calvect->GetDetCha0(k)) return kFALSE; | |
342 | if(fDetCha2[k] != calvect->GetDetCha2(k)) return kFALSE; | |
343 | } | |
55a288e5 | 344 | |
3a0f6479 | 345 | //printf("pass0!\n"); |
55a288e5 | 346 | |
3a0f6479 | 347 | // Add |
348 | for (Int_t idet = 0; idet < 540; idet++){ | |
349 | ||
350 | const AliTRDarrayI *phEntriesvect = calvect->GetPHEntries(idet); | |
351 | const AliTRDarrayF *phMeanvect = calvect->GetPHMean(idet); | |
352 | const AliTRDarrayF *phSquaresvect = calvect->GetPHSquares(idet); | |
353 | ||
354 | const AliTRDarrayI *prfEntriesvect = calvect->GetPRFEntries(idet); | |
355 | const AliTRDarrayF *prfMeanvect = calvect->GetPRFMean(idet); | |
356 | const AliTRDarrayF *prfSquaresvect = calvect->GetPRFSquares(idet); | |
357 | ||
358 | const AliTRDarrayI *chEntriesvect = calvect->GetCHEntries(idet); | |
359 | ||
360 | //printf("idet %d!\n",idet); | |
361 | ||
362 | //printf("phEntriesvect %d\n",(Bool_t) phEntriesvect); | |
363 | //printf("phMeanvect %d\n",(Bool_t) phMeanvect); | |
364 | //printf("phSquaresvect %d\n",(Bool_t) phSquaresvect); | |
365 | ||
366 | //printf("prfEntriesvect %d\n",(Bool_t) prfEntriesvect); | |
367 | //printf("prfMeanvect %d\n",(Bool_t) prfMeanvect); | |
368 | //printf("prfSquaresvect %d\n",(Bool_t) prfSquaresvect); | |
369 | ||
370 | //printf("chEntriesvect %d\n",(Bool_t) chEntriesvect); | |
371 | ||
372 | if ( phEntriesvect != 0x0 ){ | |
373 | //Take the stuff | |
374 | fPHEntries = ((AliTRDarrayI *)GetPHEntries(idet,kTRUE)); | |
375 | fPHMean = ((AliTRDarrayF *)GetPHMean(idet,kTRUE)); | |
376 | fPHSquares = ((AliTRDarrayF *)GetPHSquares(idet,kTRUE)); | |
377 | Int_t total = fPHEntries->GetSize(); | |
378 | // Add | |
379 | for(Int_t k = 0; k < total; k++){ | |
380 | Int_t entries = fPHEntries->At(k); | |
381 | Float_t mean = fPHMean->At(k); | |
382 | Float_t square = fPHSquares->At(k); | |
383 | ||
384 | Int_t entriesn = entries+phEntriesvect->At(k); | |
385 | if(entriesn <= 0) continue; | |
386 | fPHEntries->AddAt(entriesn,k); | |
387 | Float_t meann = (mean*((Float_t)entries)+phMeanvect->At(k)*((Float_t)phEntriesvect->At(k)))/((Float_t)entriesn); | |
388 | fPHMean->AddAt(meann,k); | |
389 | Float_t sq = phSquaresvect->At(k)*((Float_t)phEntriesvect->At(k)); | |
390 | Float_t squaren = ((square*((Float_t)entries))+sq)/((Float_t)entriesn); | |
391 | fPHSquares->AddAt(squaren,k); | |
392 | //printf("test ph!\n"); | |
393 | } | |
394 | } | |
395 | ||
396 | if ( prfEntriesvect != 0x0 ){ | |
397 | //Take the stuff | |
398 | fPRFEntries = ((AliTRDarrayI *)GetPRFEntries(idet,kTRUE)); | |
399 | fPRFMean = ((AliTRDarrayF *)GetPRFMean(idet,kTRUE)); | |
400 | fPRFSquares = ((AliTRDarrayF *)GetPRFSquares(idet,kTRUE)); | |
401 | Int_t total = fPRFEntries->GetSize(); | |
402 | // Add | |
403 | for(Int_t k = 0; k < total; k++){ | |
404 | Int_t entries = fPRFEntries->At(k); | |
405 | Float_t mean = fPRFMean->At(k); | |
406 | Float_t square = fPRFSquares->At(k); | |
407 | ||
408 | //printf("entries0 %d\n",entries); | |
409 | //printf("mean0 %f\n",mean); | |
410 | //printf("square0 %f\n",square); | |
411 | ||
412 | //printf("entries1 %d\n",prfEntriesvect->At(k)); | |
413 | //printf("mean1 %f\n",prfMeanvect->At(k)); | |
414 | //printf("square1 %f\n",prfSquaresvect->At(k)); | |
415 | ||
55a288e5 | 416 | |
3a0f6479 | 417 | //printf("entries0 size %d\n",fPRFEntries->GetSize()); |
418 | //printf("mean0 size %d\n",fPRFMean->GetSize()); | |
419 | //printf("squares0 size %d\n",fPRFSquares->GetSize()); | |
55a288e5 | 420 | |
3a0f6479 | 421 | //printf("entries1 size %d\n",prfEntriesvect->GetSize()); |
422 | //printf("mean1 size %d\n",prfMeanvect->GetSize()); | |
423 | //printf("squares1 size %d\n",prfSquaresvect->GetSize()); | |
55a288e5 | 424 | |
55a288e5 | 425 | |
3a0f6479 | 426 | Int_t entriesn = entries+prfEntriesvect->At(k); |
427 | if(entriesn <= 0) continue; | |
428 | fPRFEntries->AddAt(entriesn,k); | |
429 | Float_t meann = (mean*((Float_t)entries)+prfMeanvect->At(k)*((Float_t)prfEntriesvect->At(k)))/((Float_t)entriesn); | |
430 | fPRFMean->AddAt(meann,k); | |
431 | Float_t sq = prfSquaresvect->At(k)*((Float_t)prfEntriesvect->At(k)); | |
432 | Float_t squaren = ((square*((Float_t)entries))+sq)/((Float_t)entriesn); | |
433 | fPRFSquares->AddAt(squaren,k); | |
434 | //printf("test prf!\n"); | |
435 | } | |
436 | } | |
55a288e5 | 437 | |
3a0f6479 | 438 | if ( chEntriesvect != 0x0 ){ |
439 | //Take the stuff | |
440 | fCHEntries = ((AliTRDarrayI *)GetCHEntries(idet,kTRUE)); | |
441 | Int_t total = fCHEntries->GetSize(); | |
442 | //if(idet == 180) printf("total %d\n",total); | |
443 | // Add | |
444 | for(Int_t k = 0; k < total; k++){ | |
445 | Int_t entries = fCHEntries->At(k); | |
446 | Int_t entriesn = entries+chEntriesvect->At(k); | |
447 | //if((idet == 180) && ((entries != 0) || (entriesn != 0))) printf("for k %d we have entries %d and entriesn %d\n",k,entries,entriesn); | |
448 | if(entriesn <= 0) continue; | |
449 | fCHEntries->AddAt(entriesn,k); | |
450 | } | |
451 | //printf("test ch!\n"); | |
452 | } | |
453 | } | |
454 | ||
455 | return kTRUE; | |
456 | } | |
55a288e5 | 457 | //_____________________________________________________________________________ |
3a0f6479 | 458 | TGraphErrors *AliTRDCalibraVector::ConvertVectorPHTGraphErrors(Int_t det, Int_t group |
459 | , const Char_t * name) | |
55a288e5 | 460 | { |
461 | // | |
3a0f6479 | 462 | // Convert the fVectorPHMean, fVectorPHSquares and fVectorPHEntries in TGraphErrors |
55a288e5 | 463 | // |
464 | ||
3a0f6479 | 465 | // Take the info |
466 | fPHEntries = ((AliTRDarrayI *)GetPHEntries(det,kTRUE)); | |
467 | fPHMean = ((AliTRDarrayF *)GetPHMean(det,kTRUE)); | |
468 | fPHSquares = ((AliTRDarrayF *)GetPHSquares(det,kTRUE)); | |
55a288e5 | 469 | |
55a288e5 | 470 | |
3a0f6479 | 471 | // Init the stuff |
55a288e5 | 472 | TGraphErrors *histo; |
55a288e5 | 473 | Float_t sf = 10.0; |
474 | AliTRDCommonParam *parCom = AliTRDCommonParam::Instance(); | |
475 | if (!parCom) { | |
476 | AliInfo("Could not get CommonParam, take the default 10MHz"); | |
477 | } | |
55a288e5 | 478 | sf = parCom->GetSamplingFrequency(); |
55a288e5 | 479 | // Axis |
480 | Double_t *x; | |
481 | Double_t *y; | |
482 | Double_t *ex; | |
483 | Double_t *ey; | |
484 | Double_t step = 0.0; | |
485 | Double_t min = 0.0; | |
3a0f6479 | 486 | x = new Double_t[fTimeMax]; // Xaxis |
487 | y = new Double_t[fTimeMax]; // Sum/entries | |
488 | ex = new Double_t[fTimeMax]; // Nentries | |
489 | ey = new Double_t[fTimeMax]; // Sum of square/nentries | |
490 | step = 1.0 / sf; | |
491 | min = 0.0; | |
492 | Int_t offset = group*fTimeMax; | |
493 | ||
55a288e5 | 494 | // Fill histo |
3a0f6479 | 495 | for (Int_t k = 0; k < fTimeMax; k++) { |
55a288e5 | 496 | x[k] = min + k*step; |
497 | y[k] = 0.0; | |
498 | ex[k] = 0.0; | |
3a0f6479 | 499 | ey[k] = 0.0; |
500 | Int_t bin = offset+k; | |
55a288e5 | 501 | // Fill only if there is more than 0 something |
3a0f6479 | 502 | if (fPHEntries->At(bin) > 0) { |
503 | ex[k] = fPHEntries->At(bin); | |
504 | y[k] = fPHMean->At(bin); | |
505 | ey[k] = fPHSquares->At(bin); | |
55a288e5 | 506 | } |
507 | } | |
508 | ||
509 | // Define the TGraphErrors | |
3a0f6479 | 510 | histo = new TGraphErrors(fTimeMax,x,y,ex,ey); |
55a288e5 | 511 | histo->SetTitle(name); |
512 | return histo; | |
513 | ||
514 | } | |
55a288e5 | 515 | //_____________________________________________________________________________ |
3a0f6479 | 516 | TGraphErrors *AliTRDCalibraVector::ConvertVectorPRFTGraphErrors(Int_t det, Int_t group |
517 | , const Char_t * name) | |
55a288e5 | 518 | { |
519 | // | |
3a0f6479 | 520 | // Convert the fVectorPRFMean, fVectorPRFSquares and fVectorPRFEntries in TGraphErrors |
55a288e5 | 521 | // |
522 | ||
3a0f6479 | 523 | // Take the info |
524 | fPRFEntries = ((AliTRDarrayI *)GetPRFEntries(det,kTRUE)); | |
525 | fPRFMean = ((AliTRDarrayF *)GetPRFMean(det,kTRUE)); | |
526 | fPRFSquares = ((AliTRDarrayF *)GetPRFSquares(det,kTRUE)); | |
55a288e5 | 527 | |
55a288e5 | 528 | |
3a0f6479 | 529 | // Init the stuff |
530 | TGraphErrors *histo; | |
531 | // Axis | |
532 | Double_t *x; | |
533 | Double_t *y; | |
534 | Double_t *ex; | |
535 | Double_t *ey; | |
536 | Double_t step = 0.0; | |
537 | Double_t min = 0.0; | |
538 | x = new Double_t[fNumberBinPRF]; // Xaxis | |
539 | y = new Double_t[fNumberBinPRF]; // Sum/entries | |
540 | ex = new Double_t[fNumberBinPRF]; // Nentries | |
541 | ey = new Double_t[fNumberBinPRF]; // Sum of square/nentries | |
542 | step = (2*TMath::Abs(fPRFRange)) / fNumberBinPRF; | |
543 | min = -TMath::Abs(fPRFRange) + step / 2.0; | |
544 | Int_t offset = group*fNumberBinPRF; | |
545 | //printf("number of total: %d\n",fNumberBinPRF); | |
546 | // Fill histo | |
547 | for (Int_t k = 0; k < fNumberBinPRF; k++) { | |
548 | x[k] = min + k*step; | |
549 | y[k] = 0.0; | |
550 | ex[k] = 0.0; | |
551 | ey[k] = 0.0; | |
552 | Int_t bin = offset+k; | |
553 | // Fill only if there is more than 0 something | |
554 | if (fPRFEntries->At(bin) > 0) { | |
555 | ex[k] = fPRFEntries->At(bin); | |
556 | y[k] = fPRFMean->At(bin); | |
557 | ey[k] = fPRFSquares->At(bin); | |
558 | } | |
559 | //printf("Number of entries %f for %d\n",ex[k],k); | |
560 | } | |
55a288e5 | 561 | |
3a0f6479 | 562 | // Define the TGraphErrors |
563 | histo = new TGraphErrors(fNumberBinPRF,x,y,ex,ey); | |
564 | histo->SetTitle(name); | |
565 | return histo; | |
566 | ||
567 | } | |
55a288e5 | 568 | //_____________________________________________________________________________ |
3a0f6479 | 569 | TH1F *AliTRDCalibraVector::ConvertVectorCHHisto(Int_t det, Int_t group |
570 | , const Char_t * name) | |
55a288e5 | 571 | { |
572 | // | |
3a0f6479 | 573 | // Convert the fVectorCHEntries in TH1F |
55a288e5 | 574 | // |
575 | ||
3a0f6479 | 576 | // Take the info |
577 | fCHEntries = ((AliTRDarrayI *)GetCHEntries(det,kTRUE)); | |
55a288e5 | 578 | |
3a0f6479 | 579 | // Init the stuff |
580 | TH1F *histo = new TH1F(name,name,fNumberBinCharge,0,300); | |
55a288e5 | 581 | histo->Sumw2(); |
3a0f6479 | 582 | Int_t offset = group*fNumberBinCharge; |
55a288e5 | 583 | // Fill histo |
3a0f6479 | 584 | for (Int_t k = 0; k < fNumberBinCharge; k++) { |
585 | Int_t bin = offset+k; | |
586 | histo->SetBinContent(k+1,fCHEntries->At(bin)); | |
587 | histo->SetBinError(k+1,TMath::Sqrt(TMath::Abs(fCHEntries->At(bin)))); | |
55a288e5 | 588 | } |
589 | ||
590 | return histo; | |
591 | ||
3a0f6479 | 592 | } |
593 | //_____________________________________________________________________ | |
0bc7827a | 594 | AliTRDarrayI* AliTRDCalibraVector::GetPHEntries(Int_t det |
595 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 596 | { |
597 | // | |
598 | // return pointer to Carge ROC Calibration | |
599 | // if force is true create a new histogram if it doesn't exist allready | |
600 | // | |
601 | TObjArray *arr = &fVectorPHEntries; | |
602 | return GetEntriesPH(det, arr, force); | |
55a288e5 | 603 | } |
3a0f6479 | 604 | //_____________________________________________________________________ |
0bc7827a | 605 | AliTRDarrayI* AliTRDCalibraVector::GetPRFEntries(Int_t det |
606 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 607 | { |
3a0f6479 | 608 | // |
609 | // return pointer to Carge ROC Calibration | |
610 | // if force is true create a new histogram if it doesn't exist allready | |
611 | // | |
612 | TObjArray *arr = &fVectorPRFEntries; | |
613 | return GetEntriesPRF(det, arr, force); | |
55a288e5 | 614 | } |
3a0f6479 | 615 | //_____________________________________________________________________ |
0bc7827a | 616 | AliTRDarrayI* AliTRDCalibraVector::GetCHEntries(Int_t det |
617 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 618 | { |
3a0f6479 | 619 | // |
620 | // return pointer to Carge ROC Calibration | |
621 | // if force is true create a new histogram if it doesn't exist allready | |
622 | // | |
623 | TObjArray *arr = &fVectorCHEntries; | |
624 | return GetEntriesCH(det, arr, force); | |
55a288e5 | 625 | } |
3a0f6479 | 626 | //_____________________________________________________________________ |
0bc7827a | 627 | AliTRDarrayF* AliTRDCalibraVector::GetPHMean(Int_t det |
628 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 629 | { |
3a0f6479 | 630 | // |
631 | // return pointer to Carge ROC Calibration | |
632 | // if force is true create a new histogram if it doesn't exist allready | |
633 | // | |
634 | TObjArray *arr = &fVectorPHMean; | |
635 | return GetMeanSquaresPH(det, arr, force); | |
55a288e5 | 636 | } |
3a0f6479 | 637 | //_____________________________________________________________________ |
0bc7827a | 638 | AliTRDarrayF* AliTRDCalibraVector::GetPHSquares(Int_t det |
639 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 640 | { |
3a0f6479 | 641 | // |
642 | // return pointer to Carge ROC Calibration | |
643 | // if force is true create a new histogram if it doesn't exist allready | |
644 | // | |
645 | TObjArray *arr = &fVectorPHSquares; | |
646 | return GetMeanSquaresPH(det, arr, force); | |
55a288e5 | 647 | } |
3a0f6479 | 648 | //_____________________________________________________________________ |
0bc7827a | 649 | AliTRDarrayF* AliTRDCalibraVector::GetPRFMean(Int_t det |
650 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 651 | { |
3a0f6479 | 652 | // |
653 | // return pointer to Carge ROC Calibration | |
654 | // if force is true create a new histogram if it doesn't exist allready | |
655 | // | |
656 | TObjArray *arr = &fVectorPRFMean; | |
657 | return GetMeanSquaresPRF(det, arr, force); | |
658 | } | |
659 | //_____________________________________________________________________ | |
0bc7827a | 660 | AliTRDarrayF* AliTRDCalibraVector::GetPRFSquares(Int_t det |
661 | , Bool_t force) /*FOLD00*/ | |
55a288e5 | 662 | { |
3a0f6479 | 663 | // |
664 | // return pointer to Carge ROC Calibration | |
665 | // if force is true create a new histogram if it doesn't exist allready | |
666 | // | |
667 | TObjArray *arr = &fVectorPRFSquares; | |
668 | return GetMeanSquaresPRF(det, arr, force); | |
669 | } | |
670 | //_____________________________________________________________________ | |
0bc7827a | 671 | AliTRDarrayI* AliTRDCalibraVector::GetEntriesCH(Int_t det |
672 | , TObjArray* arr | |
673 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 674 | { |
675 | // | |
676 | // return pointer to AliTRDarrayI Entries | |
677 | // if force is true create a new AliTRDarrayI if it doesn't exist allready | |
678 | // | |
679 | if ( !force || arr->UncheckedAt(det) ) | |
680 | return (AliTRDarrayI*)arr->UncheckedAt(det); | |
681 | ||
682 | // if we are forced and AliTRDarrayI doesn't yes exist create it | |
683 | AliTRDarrayI *croc = new AliTRDarrayI(); | |
053767a4 | 684 | Int_t stack = GetStack(det); |
685 | Int_t ngroup = 0; | |
686 | if(stack == 2) ngroup = fDetCha2[0]*fNumberBinCharge; | |
3a0f6479 | 687 | else ngroup = fDetCha0[0]*fNumberBinCharge; |
688 | // init | |
689 | croc->Expand(ngroup); | |
690 | for(Int_t k = 0; k < ngroup; k++){ | |
691 | croc->AddAt(0,k); | |
55a288e5 | 692 | } |
3a0f6479 | 693 | arr->AddAt(croc,det); |
694 | return croc; | |
695 | } | |
696 | //_____________________________________________________________________ | |
0bc7827a | 697 | AliTRDarrayI* AliTRDCalibraVector::GetEntriesPRF(Int_t det |
698 | , TObjArray* arr | |
699 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 700 | { |
701 | // | |
702 | // return pointer to AliTRDarrayI Entries | |
703 | // if force is true create a new AliTRDarrayI if it doesn't exist allready | |
704 | // | |
705 | if ( !force || arr->UncheckedAt(det) ) | |
706 | return (AliTRDarrayI*)arr->UncheckedAt(det); | |
707 | ||
708 | // if we are forced and AliTRDarrayI doesn't yes exist create it | |
709 | AliTRDarrayI *croc = new AliTRDarrayI(); | |
053767a4 | 710 | Int_t stack = GetStack(det); |
711 | Int_t ngroup = 0; | |
712 | if(stack == 2) ngroup = fDetCha2[2]*fNumberBinPRF; | |
3a0f6479 | 713 | else ngroup = fDetCha0[2]*fNumberBinPRF; |
714 | // init | |
715 | croc->Expand(ngroup); | |
716 | for(Int_t k = 0; k < ngroup; k++){ | |
717 | croc->AddAt(0,k); | |
55a288e5 | 718 | } |
3a0f6479 | 719 | arr->AddAt(croc,det); |
720 | return croc; | |
55a288e5 | 721 | |
3a0f6479 | 722 | } |
723 | //_____________________________________________________________________ | |
0bc7827a | 724 | AliTRDarrayI* AliTRDCalibraVector::GetEntriesPH(Int_t det |
725 | , TObjArray* arr | |
726 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 727 | { |
728 | // | |
729 | // return pointer to AliTRDarrayI Entries | |
730 | // if force is true create a new AliTRDarrayI if it doesn't exist allready | |
731 | // | |
732 | if ( !force || arr->UncheckedAt(det) ) | |
733 | return (AliTRDarrayI*)arr->UncheckedAt(det); | |
734 | ||
735 | // if we are forced and AliTRDarrayI doesn't yes exist create it | |
736 | AliTRDarrayI *croc = new AliTRDarrayI(); | |
053767a4 | 737 | Int_t stack = GetStack(det); |
738 | Int_t ngroup = 0; | |
739 | if(stack == 2) ngroup = fDetCha2[1]*fTimeMax; | |
3a0f6479 | 740 | else ngroup = fDetCha0[1]*fTimeMax; |
741 | // init | |
742 | croc->Expand(ngroup); | |
743 | for(Int_t k = 0; k < ngroup; k++){ | |
744 | croc->AddAt(0,k); | |
55a288e5 | 745 | } |
3a0f6479 | 746 | arr->AddAt(croc,det); |
747 | return croc; | |
55a288e5 | 748 | |
3a0f6479 | 749 | } |
750 | //_____________________________________________________________________ | |
0bc7827a | 751 | AliTRDarrayF* AliTRDCalibraVector::GetMeanSquaresPH(Int_t det |
752 | , TObjArray* arr | |
753 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 754 | { |
755 | // | |
756 | // return pointer to AliTRDarrayF Mean or Squares | |
757 | // if force is true create a new AliTRDarrayF if it doesn't exist allready | |
758 | // | |
759 | if ( !force || arr->UncheckedAt(det) ) | |
760 | return (AliTRDarrayF*)arr->UncheckedAt(det); | |
761 | ||
762 | // if we are forced and AliTRDarrayF doesn't yes exist create it | |
763 | AliTRDarrayF *croc = new AliTRDarrayF(); | |
053767a4 | 764 | Int_t stack = GetStack(det); |
765 | Int_t ngroup = 0; | |
766 | if(stack == 2) ngroup = fDetCha2[1]*fTimeMax; | |
3a0f6479 | 767 | else ngroup = fDetCha0[1]*fTimeMax; |
768 | // init | |
769 | croc->Expand(ngroup); | |
770 | for(Int_t k = 0; k < ngroup; k++){ | |
771 | croc->AddAt(0.0,k); | |
55a288e5 | 772 | } |
3a0f6479 | 773 | arr->AddAt(croc,det); |
774 | return croc; | |
775 | } | |
776 | //_____________________________________________________________________ | |
0bc7827a | 777 | AliTRDarrayF* AliTRDCalibraVector::GetMeanSquaresPRF(Int_t det |
778 | , TObjArray* arr | |
779 | , Bool_t force) /*FOLD00*/ | |
3a0f6479 | 780 | { |
781 | // | |
782 | // return pointer to AliTRDarrayF Mean or Squares | |
783 | // if force is true create a new AliTRDarrayF if it doesn't exist allready | |
784 | // | |
785 | if ( !force || arr->UncheckedAt(det) ) | |
786 | return (AliTRDarrayF*)arr->UncheckedAt(det); | |
787 | ||
788 | // if we are forced and AliTRDarrayF doesn't yes exist create it | |
789 | AliTRDarrayF *croc = new AliTRDarrayF(); | |
053767a4 | 790 | Int_t stack = GetStack(det); |
791 | Int_t ngroup = 0; | |
792 | if(stack == 2) ngroup = fDetCha2[2]*fNumberBinPRF; | |
3a0f6479 | 793 | else ngroup = fDetCha0[2]*fNumberBinPRF; |
794 | // init | |
795 | croc->Expand(ngroup); | |
796 | for(Int_t k = 0; k < ngroup; k++){ | |
797 | croc->AddAt(0.0,k); | |
55a288e5 | 798 | } |
3a0f6479 | 799 | arr->AddAt(croc,det); |
800 | return croc; | |
55a288e5 | 801 | } |
55a288e5 | 802 | //_____________________________________________________________________________ |
053767a4 | 803 | Int_t AliTRDCalibraVector::GetStack(Int_t d) const |
55a288e5 | 804 | { |
805 | // | |
053767a4 | 806 | // Reconstruct the stack number from the detector number |
55a288e5 | 807 | // |
808 | ||
3a0f6479 | 809 | return ((Int_t) (d % 30) / 6); |
55a288e5 | 810 | |
811 | } | |
3a0f6479 | 812 |