]>
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 | ||
18 | ///////////////////////////////////////////////////////////////////////////////// | |
19 | // | |
20 | // AliTRDCalibraVector | |
21 | // | |
22 | // This class is for the vector methode of the TRD calibration. | |
23 | // | |
24 | // Author: | |
25 | // R. Bailhache (R.Bailhache@gsi.de) | |
26 | // | |
27 | ////////////////////////////////////////////////////////////////////////////////////// | |
28 | ||
29 | #include <TGraphErrors.h> | |
30 | #include <TH1F.h> | |
31 | #include <TTree.h> | |
32 | #include <TObjArray.h> | |
33 | #include <TMath.h> | |
34 | #include <TChain.h> | |
35 | #include <TDirectory.h> | |
36 | #include <TROOT.h> | |
37 | #include <TFile.h> | |
38 | ||
39 | #include "AliLog.h" | |
40 | ||
41 | #include "AliTRDCalibraVector.h" | |
42 | #include "AliTRDCommonParam.h" | |
43 | ||
44 | ClassImp(AliTRDCalibraVector) | |
45 | ||
46 | //______________________________________________________________________________________ | |
47 | AliTRDCalibraVector::AliTRDCalibraVector() | |
48 | :TObject() | |
49 | ,fVectorPH(new TObjArray()) | |
50 | ,fPlaPH(new TObjArray()) | |
51 | ,fVectorCH(new TObjArray()) | |
52 | ,fPlaCH(new TObjArray()) | |
53 | ,fVectorPRF(new TObjArray()) | |
54 | ,fPlaPRF(new TObjArray()) | |
55 | ,fNumberBinCharge(0) | |
56 | ,fNumberBinPRF(0) | |
57 | ,fTimeMax(0) | |
170c35f1 | 58 | ,fPRFRange(1.5) |
55a288e5 | 59 | { |
60 | // | |
61 | // Default constructor | |
62 | // | |
63 | ||
64 | } | |
65 | ||
66 | //______________________________________________________________________________________ | |
67 | AliTRDCalibraVector::AliTRDCalibraVector(const AliTRDCalibraVector &c) | |
68 | :TObject(c) | |
69 | ,fVectorPH(new TObjArray()) | |
70 | ,fPlaPH(new TObjArray()) | |
71 | ,fVectorCH(new TObjArray()) | |
72 | ,fPlaCH(new TObjArray()) | |
73 | ,fVectorPRF(new TObjArray()) | |
74 | ,fPlaPRF(new TObjArray()) | |
170c35f1 | 75 | ,fNumberBinCharge(c.fNumberBinCharge) |
76 | ,fNumberBinPRF(c.fNumberBinPRF) | |
77 | ,fTimeMax(c.fTimeMax) | |
78 | ,fPRFRange(c.fPRFRange) | |
55a288e5 | 79 | { |
80 | // | |
81 | // Copy constructor | |
82 | // | |
170c35f1 | 83 | for(Int_t k = 0; k < c.fVectorPH->GetEntriesFast(); k++){ |
84 | AliTRDPInfo *obj = new AliTRDPInfo(); | |
85 | UShort_t *entries = new UShort_t[fTimeMax]; | |
86 | Float_t *sum = new Float_t[fTimeMax]; | |
87 | Float_t *sumsquare = new Float_t[fTimeMax]; | |
88 | for(Int_t i = 0; i < fTimeMax; i++){ | |
89 | entries[i] = ((AliTRDPInfo *)c.fVectorPH->UncheckedAt(k))->GetEntries()[i]; | |
90 | sum[i] = ((AliTRDPInfo *)c.fVectorPH->UncheckedAt(k))->GetSum()[i]; | |
91 | sumsquare[i] = ((AliTRDPInfo *)c.fVectorPH->UncheckedAt(k))->GetSumSquare()[i]; | |
92 | } | |
93 | obj->SetEntries(entries); | |
94 | obj->SetSum(sum); | |
95 | obj->SetSumSquare(sumsquare); | |
96 | fVectorPH->AddAt((TObject *)obj,k); | |
97 | } | |
98 | for(Int_t k = 0; k < c.fVectorPRF->GetEntriesFast(); k++){ | |
99 | AliTRDPInfo *obj = new AliTRDPInfo(); | |
100 | UShort_t *entries = new UShort_t[fNumberBinPRF]; | |
101 | Float_t *sum = new Float_t[fNumberBinPRF]; | |
102 | Float_t *sumsquare = new Float_t[fNumberBinPRF]; | |
103 | for(Int_t i = 0; i < fNumberBinPRF; i++){ | |
104 | entries[i] = ((AliTRDPInfo *)c.fVectorPRF->UncheckedAt(k))->GetEntries()[i]; | |
105 | sum[i] = ((AliTRDPInfo *)c.fVectorPRF->UncheckedAt(k))->GetSum()[i]; | |
106 | sumsquare[i] = ((AliTRDPInfo *)c.fVectorPRF->UncheckedAt(k))->GetSumSquare()[i]; | |
107 | } | |
108 | obj->SetEntries(entries); | |
109 | obj->SetSum(sum); | |
110 | obj->SetSumSquare(sumsquare); | |
111 | fVectorPRF->AddAt((TObject *)obj,k); | |
112 | } | |
113 | for(Int_t k = 0; k < c.fVectorCH->GetEntriesFast(); k++){ | |
114 | AliTRDCTInfo *obj = new AliTRDCTInfo(); | |
115 | UShort_t *entries = new UShort_t[fNumberBinCharge]; | |
116 | for(Int_t i = 0; i < fNumberBinCharge; i++){ | |
117 | entries[i] = ((AliTRDCTInfo *)c.fVectorCH->UncheckedAt(k))->GetEntries()[i]; | |
118 | } | |
119 | obj->SetEntries(entries); | |
120 | fVectorCH->AddAt((TObject *)obj,k); | |
121 | } | |
122 | for(Int_t k = 0; k < c.fPlaPH->GetEntriesFast(); k++){ | |
123 | AliTRDPlace *obj = new AliTRDPlace(); | |
124 | obj->SetPlace(((AliTRDPlace *)c.fPlaPH->UncheckedAt(k))->GetPlace()); | |
125 | fPlaPH->AddAt((TObject *)obj,k); | |
126 | } | |
127 | for(Int_t k = 0; k < c.fPlaCH->GetEntriesFast(); k++){ | |
128 | AliTRDPlace *obj = new AliTRDPlace(); | |
129 | obj->SetPlace(((AliTRDPlace *)c.fPlaCH->UncheckedAt(k))->GetPlace()); | |
130 | fPlaCH->AddAt((TObject *)obj,k); | |
131 | } | |
132 | for(Int_t k = 0; k < c.fPlaPRF->GetEntriesFast(); k++){ | |
133 | AliTRDPlace *obj = new AliTRDPlace(); | |
134 | obj->SetPlace(((AliTRDPlace *)c.fPlaPRF->UncheckedAt(k))->GetPlace()); | |
135 | fPlaPRF->AddAt((TObject *)obj,k); | |
136 | } | |
55a288e5 | 137 | |
138 | } | |
55a288e5 | 139 | //____________________________________________________________________________________ |
140 | AliTRDCalibraVector::~AliTRDCalibraVector() | |
141 | { | |
142 | // | |
143 | // AliTRDCalibraVector destructor | |
144 | // | |
145 | ||
146 | } | |
147 | ||
148 | //_____________________________________________________________________________ | |
149 | Int_t AliTRDCalibraVector::SearchBin(Float_t value, Int_t i) const | |
150 | { | |
151 | // | |
152 | // Search the bin | |
153 | // | |
154 | ||
170c35f1 | 155 | Int_t reponse = 0; |
156 | Float_t fbinmin = 0; | |
157 | Float_t fbinmax = value; | |
158 | Int_t fNumberOfBin = -1; | |
55a288e5 | 159 | |
160 | // Charge | |
161 | if (i == 0) { | |
170c35f1 | 162 | fbinmax = 300.0; |
163 | fbinmin = 0.0; | |
55a288e5 | 164 | fNumberOfBin = fNumberBinCharge; |
165 | } | |
166 | ||
167 | // PRF | |
168 | if (i == 2) { | |
170c35f1 | 169 | fbinmax = TMath::Abs(fPRFRange); |
170 | fbinmin = -TMath::Abs(fPRFRange); | |
55a288e5 | 171 | fNumberOfBin = fNumberBinPRF; |
172 | } | |
173 | ||
174 | // Return -1 if out | |
175 | if ((value >= fbinmax) || | |
176 | (value < fbinmin)) { | |
177 | return -1; | |
178 | } | |
179 | // Sinon | |
180 | else { | |
181 | reponse = (Int_t) ((fNumberOfBin*(value-fbinmin)) / (fbinmax-fbinmin)); | |
182 | } | |
183 | ||
184 | return reponse; | |
185 | ||
186 | } | |
187 | ||
188 | //_____________________________________________________________________________ | |
189 | Int_t AliTRDCalibraVector::SearchInVector(Int_t group, Int_t i) const | |
190 | { | |
191 | // | |
192 | // Search if the calibration group "group" has already been | |
193 | // initialised by a previous track in the vector | |
194 | // | |
195 | ||
196 | if (i == 0) { | |
197 | for (Int_t k = 0; k < (Int_t) fPlaCH->GetEntriesFast(); k++) { | |
198 | if (((AliTRDPlace *) fPlaCH->At(k))->GetPlace() == group) { | |
199 | return k; | |
200 | } | |
201 | } | |
202 | return -1; | |
203 | } | |
204 | ||
205 | if (i == 1) { | |
206 | for (Int_t k = 0; k < (Int_t) fPlaPH->GetEntriesFast(); k++) { | |
207 | if (((AliTRDPlace *) fPlaPH->At(k))->GetPlace() == group) { | |
208 | return k; | |
209 | } | |
210 | } | |
211 | return -1; | |
212 | } | |
213 | ||
214 | if (i == 2) { | |
215 | for (Int_t k = 0; k < (Int_t) fPlaPRF->GetEntriesFast(); k++) { | |
216 | if (((AliTRDPlace *) fPlaPRF->At(k))->GetPlace() == group) { | |
217 | return k; | |
218 | } | |
219 | } | |
220 | return -1; | |
221 | } | |
222 | ||
223 | return -1; | |
224 | ||
225 | } | |
226 | ||
227 | //_____________________________________________________________________________ | |
228 | Int_t AliTRDCalibraVector::SearchInTreeVector(TObjArray *vectorplace, Int_t group) const | |
229 | { | |
230 | // | |
231 | // Search if the calibration group "group" is present in the tree | |
232 | // | |
233 | ||
234 | for (Int_t k = 0; k < (Int_t) vectorplace->GetEntriesFast(); k++) { | |
235 | if (((AliTRDPlace *) vectorplace->At(k))->GetPlace() == group) { | |
236 | return k; | |
237 | } | |
238 | } | |
239 | ||
240 | return -1; | |
241 | ||
242 | } | |
243 | ||
244 | //_____________________________________________________________________________ | |
245 | Bool_t AliTRDCalibraVector::UpdateVectorCH(Int_t group, Float_t value) | |
246 | { | |
247 | // | |
248 | // Fill the vector if a new calibration group "group" or update the | |
249 | // values of the calibration group "group" if already here | |
250 | // | |
251 | ||
252 | // Search bin | |
253 | Int_t bin = SearchBin(value,0); | |
254 | // Out | |
255 | if ((bin < 0) || (bin >= fNumberBinCharge)) { | |
256 | return kFALSE; | |
257 | } | |
258 | ||
259 | // Search place | |
260 | Int_t place = SearchInVector(group,0); | |
261 | ||
262 | // New group | |
263 | if (place == -1) { | |
264 | AliTRDPlace *placegroup = new AliTRDPlace(); | |
265 | placegroup->SetPlace(group); | |
266 | fPlaCH->Add((TObject *) placegroup); | |
267 | // Variable | |
268 | AliTRDCTInfo *fCHInfo = new AliTRDCTInfo(); | |
269 | UShort_t *entries = new UShort_t[fNumberBinCharge]; | |
270 | // Initialise first | |
271 | for(Int_t k = 0; k < fNumberBinCharge; k++) { | |
272 | entries[k] = 0; | |
273 | } | |
274 | // Add the value | |
275 | entries[bin]= 1; | |
276 | // Set | |
277 | fCHInfo->SetEntries(entries); | |
278 | // Set in the vector | |
279 | fVectorCH->Add((TObject *) fCHInfo); | |
280 | } | |
281 | // Group already exits | |
282 | else { | |
283 | // Variable | |
284 | AliTRDCTInfo *fCHInfo = new AliTRDCTInfo(); | |
285 | // Retrieve | |
286 | fCHInfo = ((AliTRDCTInfo *) fVectorCH->At(place)); | |
287 | UShort_t *entries = fCHInfo->GetEntries(); | |
288 | // Add | |
289 | entries[bin]++; | |
290 | // Set | |
291 | fCHInfo->SetEntries(entries); | |
292 | // Update the vector | |
293 | fVectorCH->AddAt((TObject *) fCHInfo,place); | |
294 | } | |
295 | ||
296 | return kTRUE; | |
297 | ||
298 | } | |
299 | ||
300 | //_____________________________________________________________________________ | |
301 | Bool_t AliTRDCalibraVector::UpdateVectorPRF(Int_t group, Float_t x, Float_t y) | |
302 | { | |
303 | // | |
304 | // Fill the vector if a new calibration group "group" or update the | |
305 | // values of the calibration group "group" if already here | |
306 | // | |
307 | ||
308 | // Search bin | |
309 | Int_t bin = SearchBin(x,2); | |
310 | // Out | |
311 | if ((bin < 0) || (bin >= fNumberBinPRF)) { | |
312 | return kFALSE; | |
313 | } | |
314 | ||
315 | // Search place | |
316 | Int_t place = SearchInVector(group,2); | |
317 | ||
318 | // New group | |
319 | if (place == -1) { | |
320 | ||
321 | AliTRDPlace *placegroup = new AliTRDPlace(); | |
322 | placegroup->SetPlace(group); | |
323 | fPlaPRF->Add((TObject *) placegroup); | |
324 | AliTRDPInfo *fPRFInfo = new AliTRDPInfo(); | |
325 | ||
326 | Float_t *sum = new Float_t[fNumberBinPRF]; | |
327 | Float_t *sumsquare = new Float_t[fNumberBinPRF]; | |
328 | UShort_t *entries = new UShort_t[fNumberBinPRF]; | |
329 | ||
330 | // Initialise first | |
331 | for (Int_t k = 0; k < fNumberBinPRF; k++) { | |
332 | sum[k] = 0.0; | |
333 | sumsquare[k] = 0.0; | |
334 | entries[k] = 0; | |
335 | } | |
336 | ||
337 | // Add the value | |
338 | sum[bin] += y; | |
339 | sumsquare[bin] += y*y; | |
340 | entries[bin]++; | |
341 | ||
342 | // Set | |
343 | fPRFInfo->SetSum(sum); | |
344 | fPRFInfo->SetSumSquare(sumsquare); | |
345 | fPRFInfo->SetEntries(entries); | |
346 | ||
347 | // Set in the vector | |
348 | fVectorPRF->Add((TObject *) fPRFInfo); | |
349 | ||
350 | } | |
351 | // Group already exits | |
352 | else { | |
353 | ||
354 | AliTRDPInfo *fPRFInfo = new AliTRDPInfo(); | |
355 | // Retrieve | |
356 | fPRFInfo = (AliTRDPInfo *) fVectorPRF->At(place); | |
357 | ||
358 | Float_t *sum = fPRFInfo->GetSum(); | |
359 | Float_t *sumsquare = fPRFInfo->GetSumSquare(); | |
360 | UShort_t *entries = fPRFInfo->GetEntries(); | |
361 | ||
362 | // Add | |
363 | Double_t calcul = (((Double_t) fPRFInfo->GetEntries()[bin]) | |
364 | * ((Double_t) fPRFInfo->GetSum()[bin]) + (Double_t) y) | |
365 | / (((Double_t) fPRFInfo->GetEntries()[bin]) + 1); | |
366 | sum[bin] = (Float_t) calcul; | |
367 | Double_t calculsquare = (((Double_t) fPRFInfo->GetSumSquare()[bin]) | |
368 | * ((Double_t) fPRFInfo->GetEntries()[bin]) + ((Double_t) y)*((Double_t) y)) | |
369 | / (((Double_t) fPRFInfo->GetEntries()[bin]) + 1); | |
370 | sumsquare[bin] = (Float_t) calculsquare; | |
371 | entries[bin]++; | |
372 | ||
373 | // Set | |
374 | fPRFInfo->SetSum(sum); | |
375 | fPRFInfo->SetSumSquare(sumsquare); | |
376 | fPRFInfo->SetEntries(entries); | |
377 | ||
378 | // Update the vector | |
379 | fVectorPRF->AddAt((TObject *) fPRFInfo,place); | |
380 | ||
381 | } | |
382 | ||
383 | return kTRUE; | |
384 | ||
385 | } | |
386 | ||
387 | //_____________________________________________________________________________ | |
388 | Bool_t AliTRDCalibraVector::UpdateVectorPH(Int_t group, Int_t time, Float_t value) | |
389 | { | |
390 | // | |
391 | // Fill the vector if a new calibration group "group" or update | |
392 | // the values of the calibration group "group" if already here | |
393 | // | |
394 | ||
395 | // Search bin | |
396 | Int_t bin = time; | |
397 | // Out | |
398 | if ((bin < 0) || | |
399 | (bin >= fTimeMax)) { | |
400 | return kFALSE; | |
401 | } | |
402 | ||
403 | // Search place | |
404 | Int_t place = SearchInVector(group,1); | |
405 | ||
406 | // New group | |
407 | if(place == -1){ | |
408 | ||
409 | AliTRDPlace *placegroup = new AliTRDPlace(); | |
410 | placegroup->SetPlace(group); | |
411 | fPlaPH->Add((TObject *) placegroup); | |
412 | AliTRDPInfo *fPHInfo = new AliTRDPInfo(); | |
413 | ||
414 | Float_t *sum = new Float_t[fTimeMax]; | |
415 | Float_t *sumsquare = new Float_t[fTimeMax]; | |
416 | UShort_t *entries = new UShort_t[fTimeMax]; | |
417 | ||
418 | // Initialise first | |
419 | for (Int_t k = 0; k < fTimeMax; k++) { | |
420 | sum[k] = 0.0; | |
421 | sumsquare[k] = 0.0; | |
422 | entries[k] = 0; | |
423 | } | |
424 | ||
425 | // Add the value | |
426 | sum[bin] += value; | |
427 | sumsquare[bin] += value*value; | |
428 | entries[bin]++; | |
429 | ||
430 | // Set | |
431 | fPHInfo->SetSum(sum); | |
432 | fPHInfo->SetSumSquare(sumsquare); | |
433 | fPHInfo->SetEntries(entries); | |
434 | ||
435 | // Set in the vector | |
436 | fVectorPH->Add((TObject *) fPHInfo); | |
437 | ||
438 | } | |
439 | // Group already exits | |
440 | else { | |
441 | ||
442 | AliTRDPInfo *fPHInfo = new AliTRDPInfo(); | |
443 | // Retrieve | |
444 | fPHInfo = (AliTRDPInfo *) fVectorPH->At(place); | |
445 | ||
446 | Float_t *sum = fPHInfo->GetSum(); | |
447 | Float_t *sumsquare = fPHInfo->GetSumSquare(); | |
448 | UShort_t *entries = fPHInfo->GetEntries(); | |
449 | ||
450 | // Add | |
451 | Double_t calcul = (((Double_t) fPHInfo->GetEntries()[bin]) | |
452 | * ((Double_t) fPHInfo->GetSum()[bin]) + (Double_t) value) | |
453 | / (((Double_t) fPHInfo->GetEntries()[bin]) + 1); | |
454 | sum[bin] = (Float_t) calcul; | |
455 | Double_t calculsquare = ((((Double_t) fPHInfo->GetSumSquare()[bin]) | |
456 | * ((Double_t) fPHInfo->GetEntries()[bin])) | |
457 | + (((Double_t) value) * ((Double_t)value))) | |
458 | / (((Double_t) fPHInfo->GetEntries()[bin]) + 1); | |
459 | sumsquare[bin] = (Float_t) calculsquare; | |
460 | entries[bin]++; | |
461 | ||
462 | // Set | |
463 | fPHInfo->SetSum(sum); | |
464 | fPHInfo->SetSumSquare(sumsquare); | |
465 | fPHInfo->SetEntries(entries); | |
466 | ||
467 | // Update the vector | |
468 | fVectorPH->AddAt((TObject *) fPHInfo,place); | |
469 | ||
470 | } | |
471 | ||
472 | return kTRUE; | |
473 | ||
474 | } | |
475 | ||
476 | //_____________________________________________________________________________ | |
477 | TGraphErrors *AliTRDCalibraVector::ConvertVectorPHisto(Int_t place | |
478 | , const Char_t * name) const | |
479 | { | |
480 | // | |
481 | // Convert the PInfo in a TGraphErrors | |
482 | // | |
483 | ||
484 | AliTRDPInfo *pInfo = new AliTRDPInfo(); | |
485 | // Retrieve | |
486 | pInfo = ((AliTRDPInfo *) fVectorPH->At(place)); | |
487 | TGraphErrors *histo; | |
488 | histo = ConvertVectorPHistoI((AliTRDPInfo *)pInfo, name); | |
489 | ||
490 | return histo; | |
491 | ||
492 | } | |
493 | ||
494 | //_____________________________________________________________________________ | |
495 | TGraphErrors *AliTRDCalibraVector::ConvertVectorPHistoI(AliTRDPInfo *pInfo | |
496 | , const Char_t *name) const | |
497 | { | |
498 | // | |
499 | // Convert the PInfo in a 1D grapherror, name must contains "PRF" | |
500 | // if PRF calibration and not "PRF" for Vdrift calibration | |
501 | // | |
502 | ||
503 | TGraphErrors *histo; | |
504 | const Char_t *pattern1 = "PRF"; | |
505 | ||
506 | Float_t sf = 10.0; | |
507 | AliTRDCommonParam *parCom = AliTRDCommonParam::Instance(); | |
508 | if (!parCom) { | |
509 | AliInfo("Could not get CommonParam, take the default 10MHz"); | |
510 | } | |
511 | ||
512 | sf = parCom->GetSamplingFrequency(); | |
513 | ||
514 | // Axis | |
515 | Double_t *x; | |
516 | Double_t *y; | |
517 | Double_t *ex; | |
518 | Double_t *ey; | |
519 | Double_t step = 0.0; | |
520 | Double_t min = 0.0; | |
521 | ||
522 | // Ntimes | |
523 | Int_t ntimes = 0; | |
524 | if (strstr(name,pattern1)) { | |
525 | ntimes = fNumberBinPRF; | |
526 | } | |
527 | else { | |
528 | ntimes = fTimeMax; | |
529 | } | |
530 | x = new Double_t[ntimes]; // Xaxis | |
170c35f1 | 531 | y = new Double_t[ntimes]; // Sum |
55a288e5 | 532 | ex = new Double_t[ntimes]; // Nentries |
533 | ey = new Double_t[ntimes]; // Sum of square/nentries | |
534 | ||
535 | // Init histo | |
536 | if (!strstr(name,pattern1)) { | |
537 | step = 1.0 / sf; | |
538 | min = 0.0; | |
539 | } | |
540 | else { | |
170c35f1 | 541 | step = (2*TMath::Abs(fPRFRange)) / fNumberBinPRF; |
542 | min = -TMath::Abs(fPRFRange) + step / 2.0; | |
55a288e5 | 543 | } |
544 | ||
545 | // Fill histo | |
546 | for (Int_t k = 0; k < ntimes; k++) { | |
547 | x[k] = min + k*step; | |
548 | y[k] = 0.0; | |
549 | ex[k] = 0.0; | |
550 | ey[k] = 0.0; | |
551 | // Fill only if there is more than 0 something | |
552 | if (pInfo->GetEntries()[k] > 0) { | |
553 | ex[k] = pInfo->GetEntries()[k]; | |
554 | y[k] = pInfo->GetSum()[k]; | |
555 | ey[k] = pInfo->GetSumSquare()[k]; | |
556 | } | |
557 | } | |
558 | ||
559 | // Define the TGraphErrors | |
560 | histo = new TGraphErrors(ntimes,x,y,ex,ey); | |
561 | histo->SetTitle(name); | |
562 | return histo; | |
563 | ||
564 | } | |
565 | ||
566 | //_____________________________________________________________________________ | |
567 | TH1F *AliTRDCalibraVector::ConvertVectorCTHisto(Int_t place | |
568 | , const Char_t * name) const | |
569 | { | |
570 | // | |
571 | // Convert the CTInfo in a 1D histo | |
572 | // | |
573 | ||
574 | AliTRDCTInfo *cHInfo = new AliTRDCTInfo(); | |
575 | // Retrieve | |
576 | cHInfo = ((AliTRDCTInfo *) fVectorCH->At(place)); | |
577 | TH1F *histo; | |
578 | histo = ConvertVectorCTHistoI((AliTRDCTInfo *)cHInfo,(const Char_t *) name); | |
579 | ||
580 | return histo; | |
581 | ||
582 | } | |
583 | ||
584 | //_____________________________________________________________________________ | |
585 | TH1F *AliTRDCalibraVector::ConvertVectorCTHistoI(AliTRDCTInfo *cTInfo | |
586 | , const Char_t * name) const | |
587 | { | |
588 | // | |
589 | // Convert the CTInfo in a 1D histo | |
590 | // | |
591 | ||
592 | TH1F *histo; | |
593 | ||
594 | Int_t ntimes = fNumberBinCharge; | |
595 | UShort_t *entries = cTInfo->GetEntries(); | |
596 | ||
597 | // Init histo | |
598 | histo = new TH1F(name,name,fNumberBinCharge,0,300); | |
599 | histo->Sumw2(); | |
600 | // Fill histo | |
601 | for (Int_t k = 0; k < ntimes; k++) { | |
602 | histo->SetBinContent(k+1,entries[k]); | |
603 | histo->SetBinError(k+1,TMath::Sqrt(TMath::Abs(entries[k]))); | |
604 | } | |
605 | ||
606 | return histo; | |
607 | ||
608 | } | |
609 | ||
610 | //_____________________________________________________________________________ | |
611 | TTree *AliTRDCalibraVector::ConvertVectorCTTreeHisto(TObjArray *vVectorCT | |
612 | , TObjArray *pPlaCT | |
613 | , const Char_t *name | |
614 | , const Char_t *nametitle) const | |
615 | { | |
616 | // | |
617 | // Convert the vector in a tree with two branchs: the group number | |
618 | // and the TH1F histo reconstructed from the vector | |
619 | // | |
620 | ||
621 | // Size of the things | |
622 | Int_t ntotal = (Int_t) pPlaCT->GetEntriesFast(); | |
623 | if (ntotal == 0) { | |
624 | AliInfo("nothing to write!"); | |
625 | TTree *treeCT = new TTree(name,nametitle); | |
626 | return treeCT; | |
627 | } | |
628 | ||
629 | // Variable of the tree | |
630 | Int_t groupnumber = -1; // Group calibration | |
631 | TH1F *histo = 0x0; | |
632 | TObjArray vectorCT = *vVectorCT; | |
633 | TObjArray plaCT = *pPlaCT; | |
634 | ||
635 | // Init the tree | |
636 | TTree *treeCT = new TTree(name,nametitle); | |
637 | treeCT->Branch("groupnumber",&groupnumber,"groupnumber/I"); | |
638 | treeCT->Branch("histo","TH1F",&histo,32000,0); | |
639 | ||
640 | // Fill | |
641 | Int_t k = 0; | |
642 | while (k < ntotal) { | |
643 | TString nome(name); | |
644 | groupnumber = ((AliTRDPlace *) plaCT.At(0))->GetPlace(); | |
645 | nome += groupnumber; | |
646 | histo = ConvertVectorCTHistoI(((AliTRDCTInfo *) vectorCT.At(0)),nome); | |
647 | treeCT->Fill(); | |
648 | vectorCT.RemoveAt(0); | |
649 | vectorCT.Compress(); | |
650 | plaCT.RemoveAt(0); | |
651 | plaCT.Compress(); | |
652 | k++; | |
653 | } | |
654 | ||
655 | return treeCT; | |
656 | ||
657 | } | |
658 | ||
659 | //_____________________________________________________________________________ | |
660 | TTree *AliTRDCalibraVector::ConvertVectorPTreeHisto(TObjArray *vVectorP | |
661 | , TObjArray *pPlaP | |
662 | , const Char_t *name | |
663 | , const Char_t *nametitle) const | |
664 | { | |
665 | // | |
666 | // Convert the vector in a tree with two branchs: the group number | |
667 | // and the TGraphErrors histo reconstructed from the vector. | |
668 | // The name must contain "PRF" for PRF calibration and not "PRF" | |
669 | // for Vdrift calibration | |
670 | // | |
671 | ||
672 | // Size of the things | |
673 | Int_t ntotal = (Int_t) pPlaP->GetEntriesFast(); | |
674 | if (ntotal == 0) { | |
675 | AliInfo("nothing to write!"); | |
676 | TTree *treeP = new TTree(name,nametitle); | |
677 | return treeP; | |
678 | } | |
679 | ||
680 | // Variable of the tree | |
681 | Int_t groupnumber = -1; // Group calibration | |
682 | TGraphErrors *histo = 0x0; | |
683 | TObjArray vectorP = *vVectorP; | |
684 | TObjArray plaP = *pPlaP; | |
685 | ||
686 | // Init the tree | |
687 | TTree *treeP = new TTree(name,nametitle); | |
688 | treeP->Branch("groupnumber",&groupnumber,"groupnumber/I"); | |
689 | treeP->Branch("histo","TGraphErrors",&histo,32000,0); | |
690 | ||
691 | // Fill | |
692 | Int_t k = 0; | |
693 | while (k < ntotal) { | |
694 | TString nome(name); | |
695 | groupnumber = ((AliTRDPlace *) plaP.At(0))->GetPlace(); | |
696 | nome += groupnumber; | |
697 | histo = ConvertVectorPHistoI((AliTRDPInfo *) vectorP.At(0),nome); | |
698 | treeP->Fill(); | |
699 | vectorP.RemoveAt(0); | |
700 | vectorP.Compress(); | |
701 | plaP.RemoveAt(0); | |
702 | plaP.Compress(); | |
703 | k++; | |
704 | } | |
705 | ||
706 | return treeP; | |
707 | ||
708 | } | |
709 | ||
710 | //_____________________________________________________________________________ | |
711 | TObjArray *AliTRDCalibraVector::ConvertTreeVector(TTree *tree) const | |
712 | { | |
713 | // | |
714 | // Convert the branch groupnumber of the tree taken from | |
715 | // TRD.calibration.root in case of vector method in a std::vector | |
716 | // to be faster | |
717 | // | |
718 | ||
719 | // Initialise | |
720 | TObjArray *vectorplace = new TObjArray(); | |
721 | ||
722 | // Variable of the tree | |
723 | Int_t groupnumber = -1; // Group calibration | |
724 | ||
725 | // Set the branch | |
726 | tree->SetBranchAddress("groupnumber",&groupnumber); | |
727 | ||
728 | // Fill | |
729 | Int_t ntotal = tree->GetEntries(); | |
730 | for (Int_t k = 0; k < ntotal; k++) { | |
731 | tree->GetEntry(k); | |
732 | AliTRDPlace *placegroupnumber = new AliTRDPlace(); | |
733 | placegroupnumber->SetPlace(groupnumber); | |
734 | vectorplace->Add((TObject *) placegroupnumber); | |
735 | } | |
736 | ||
737 | return vectorplace; | |
738 | ||
739 | } | |
740 | ||
741 | //_____________________________________________________________________________ | |
742 | Bool_t AliTRDCalibraVector::MergeVectorCT(TObjArray *vVectorCT2, TObjArray *pPlaCT2) | |
743 | { | |
744 | // | |
745 | // Add the two vectors and place the result in the first | |
746 | // | |
747 | ||
748 | if (((Int_t) pPlaCT2->GetEntriesFast()) != ((Int_t) vVectorCT2->GetEntriesFast())){ | |
749 | AliInfo("VectorCT2 doesn't correspond to PlaCT2!"); | |
750 | return kFALSE; | |
751 | } | |
752 | ||
753 | // CH case | |
754 | for (Int_t k = 0; k < (Int_t) fPlaCH->GetEntriesFast(); k++) { | |
755 | ||
756 | // Look if PlaCT1[k] it is also in the second vector | |
757 | Int_t place = -1; | |
758 | for (Int_t j = 0; j < (Int_t) pPlaCT2->GetEntriesFast(); j++) { | |
759 | if (((AliTRDPlace *) pPlaCT2->At(j))->GetPlace() == | |
760 | ((AliTRDPlace *) fPlaCH->At(k))->GetPlace()) { | |
761 | place = j; | |
762 | break; | |
763 | } | |
764 | } | |
765 | ||
766 | // If not in the second vector nothing to do | |
767 | ||
768 | // If in the second vector | |
769 | if (place != -1) { | |
770 | ||
771 | AliTRDCTInfo *fCTInfo = new AliTRDCTInfo(); | |
772 | UShort_t *entries = new UShort_t[fNumberBinCharge]; | |
773 | ||
774 | for (Int_t nu = 0; nu < fNumberBinCharge; nu++) { | |
775 | entries[nu] = ((AliTRDCTInfo *) fVectorCH->At(((AliTRDPlace *) fPlaCH->At(k))->GetPlace()))->GetEntries()[nu] | |
776 | + ((AliTRDCTInfo *) vVectorCT2->At(((AliTRDPlace *) fPlaCH->At(k))->GetPlace()))->GetEntries()[nu]; | |
777 | } | |
778 | ||
779 | // Set | |
780 | fCTInfo->SetEntries(entries); | |
781 | ||
782 | // Nothing to do on PlaCT1 | |
783 | ||
784 | // Update the vector | |
785 | fVectorCH->AddAt((TObject *) fCTInfo,((AliTRDPlace *) fPlaCH->At(k))->GetPlace()); | |
786 | ||
787 | } | |
788 | ||
789 | } | |
790 | ||
791 | // And at the end the vector in CT2 but not in CH1 | |
792 | for (Int_t k = 0; k < (Int_t) pPlaCT2->GetEntriesFast(); k++) { | |
793 | ||
794 | // Look if pPlaCT2[k] it is also in the second vector | |
795 | Int_t place = -1; | |
796 | for (Int_t j = 0; j < (Int_t) fPlaCH->GetEntriesFast(); j++) { | |
797 | if (((AliTRDPlace *) fPlaCH->At(j))->GetPlace() == ((AliTRDPlace *) pPlaCT2->At(k))->GetPlace()) { | |
798 | place = j; | |
799 | break; | |
800 | } | |
801 | } | |
802 | ||
803 | // If not in the first vector | |
804 | if (place == -1) { | |
805 | ||
806 | AliTRDCTInfo *fCTInfo = new AliTRDCTInfo(); | |
807 | fCTInfo = ((AliTRDCTInfo *) vVectorCT2->At(((AliTRDPlace *) pPlaCT2->At(k))->GetPlace())); | |
808 | ||
809 | // Add at the end | |
810 | fPlaCH->Add((TObject *) (pPlaCT2->At(k))); | |
811 | fVectorCH->Add((TObject *) fCTInfo); | |
812 | ||
813 | } | |
814 | ||
815 | } | |
816 | ||
817 | return kTRUE; | |
818 | ||
819 | } | |
820 | ||
821 | //_____________________________________________________________________________ | |
822 | Bool_t AliTRDCalibraVector::MergeVectorP(TObjArray *vVectorP2 | |
823 | , TObjArray *pPlaP2 | |
824 | , Int_t i) | |
825 | { | |
826 | // | |
827 | // Add the two vectors and place the result in the first | |
828 | // | |
829 | ||
830 | if (((Int_t) pPlaP2->GetEntriesFast()) != ((Int_t) vVectorP2->GetEntriesFast())) { | |
831 | AliInfo("VectorP2 doesn't correspond to PlaP2!"); | |
832 | return kFALSE; | |
833 | } | |
834 | ||
835 | // PH case | |
836 | if (i == 1) { | |
837 | ||
838 | for (Int_t k = 0; k < (Int_t) fPlaPH->GetEntriesFast(); k++) { | |
839 | ||
840 | // Look if fPlaPH[k] it is also in the second vector | |
841 | Int_t place = -1; | |
842 | for (Int_t j = 0; j < (Int_t) pPlaP2->GetEntriesFast(); j++) { | |
843 | if (((AliTRDPlace *) pPlaP2->At(j))->GetPlace() == ((AliTRDPlace *) fPlaPH->At(k))->GetPlace()) { | |
844 | place = j; | |
845 | break; | |
846 | } | |
847 | } | |
848 | ||
849 | // If not in the second vector nothing to do | |
850 | ||
851 | // If in the second vector | |
852 | if (place != -1) { | |
853 | ||
854 | AliTRDPInfo *fPInfo = new AliTRDPInfo(); | |
855 | UShort_t *entries = new UShort_t[fTimeMax]; | |
856 | Float_t *sum = new Float_t[fTimeMax]; | |
857 | Float_t *sumsquare = new Float_t[fTimeMax]; | |
858 | ||
859 | for (Int_t nu = 0; nu < fTimeMax; nu++) { | |
860 | ||
861 | entries[nu] = ((AliTRDPInfo *) fVectorPH->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu] | |
862 | + ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu]; | |
863 | ||
864 | Double_t calcul = ((((Double_t) ((AliTRDPInfo *) fVectorPH->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetSum()[nu]) | |
865 | * ((Double_t) ((AliTRDPInfo *) fVectorPH->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu])) | |
866 | + (((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetSum()[nu]) | |
867 | * ((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu]))) | |
868 | / ((Double_t) fPInfo->GetEntries()[nu]); | |
869 | ||
870 | sum[nu] = (Float_t) calcul; | |
871 | ||
872 | Double_t calculsquare = ((((Double_t) ((AliTRDPInfo *) fVectorPH->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetSumSquare()[nu]) | |
873 | * ((Double_t) ((AliTRDPInfo *) fVectorPH->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu])) | |
874 | + (((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetSumSquare()[nu]) | |
875 | * ((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPH->At(k))->GetPlace()))->GetEntries()[nu]))) | |
876 | / ((Double_t) fPInfo->GetEntries()[nu]); | |
877 | ||
878 | sumsquare[nu] = calculsquare; | |
879 | ||
880 | } | |
881 | ||
882 | // Set | |
883 | fPInfo->SetSum(sum); | |
884 | fPInfo->SetSumSquare(sumsquare); | |
885 | fPInfo->SetEntries(entries); | |
886 | ||
887 | // Nothing to do on PlaCT1 | |
888 | ||
889 | // Update the vector VectorCT1 | |
890 | fVectorPH->AddAt((TObject *) fPInfo,((AliTRDPlace *) fPlaPH->At(k))->GetPlace()); | |
891 | ||
892 | } | |
893 | ||
894 | } | |
895 | ||
896 | // And at the end the vector in P2 but not in CH1 | |
897 | for (Int_t k = 0; k < (Int_t) pPlaP2->GetEntriesFast(); k++) { | |
898 | ||
899 | // Look if PlaCT2[k] it is also in the second vector | |
900 | Int_t place = -1; | |
901 | for (Int_t j = 0; j < (Int_t) fPlaPH->GetEntriesFast(); j++) { | |
902 | if (((AliTRDPlace *) fPlaPH->At(j))->GetPlace() == ((AliTRDPlace *) pPlaP2->At(k))->GetPlace()) { | |
903 | place = j; | |
904 | break; | |
905 | } | |
906 | } | |
907 | ||
908 | // If not in the first vector | |
909 | if (place == -1) { | |
910 | ||
911 | AliTRDPInfo *fPInfo = new AliTRDPInfo(); | |
912 | fPInfo = (AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) pPlaP2->At(k))->GetPlace()); | |
913 | ||
914 | // Add at the end of CH1 | |
915 | fPlaPH->Add(((TObject *) pPlaP2->At(k))); | |
916 | fVectorPH->Add((TObject *) fPInfo); | |
917 | ||
918 | } | |
919 | ||
920 | } | |
921 | ||
922 | } | |
923 | ||
924 | // PRF case | |
925 | if (i == 1) { | |
926 | ||
927 | for (Int_t k = 0; k < (Int_t) fPlaPRF->GetEntriesFast(); k++) { | |
928 | ||
929 | // Look if fPlaPRF[k] it is also in the second vector | |
930 | Int_t place = -1; | |
931 | for (Int_t j = 0; j < (Int_t) pPlaP2->GetEntriesFast(); j++) { | |
932 | if (((AliTRDPlace *) pPlaP2->At(j))->GetPlace() == ((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()) { | |
933 | place = j; | |
934 | break; | |
935 | } | |
936 | } | |
937 | ||
938 | // If not in the second vector nothing to do | |
939 | ||
940 | // If in the second vector | |
941 | if (place != -1) { | |
942 | ||
943 | AliTRDPInfo *fPInfo = new AliTRDPInfo(); | |
944 | UShort_t *entries = new UShort_t[fNumberBinPRF]; | |
945 | Float_t *sum = new Float_t[fNumberBinPRF]; | |
946 | Float_t *sumsquare = new Float_t[fNumberBinPRF]; | |
947 | ||
948 | for (Int_t nu = 0; nu < fNumberBinPRF; nu++) { | |
949 | ||
950 | entries[nu] = ((AliTRDPInfo *) fVectorPRF->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu] | |
951 | + ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu]; | |
952 | ||
953 | Double_t calcul = ((((Double_t) ((AliTRDPInfo *) fVectorPRF->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetSum()[nu]) | |
954 | * ((Double_t) ((AliTRDPInfo *) fVectorPRF->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu])) | |
955 | + (((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetSum()[nu]) | |
956 | * ((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu]))) | |
957 | / ((Double_t) fPInfo->GetEntries()[nu]); | |
958 | ||
959 | sum[nu] = (Float_t) calcul; | |
960 | ||
961 | Double_t calculsquare = ((((Double_t) ((AliTRDPInfo *) fVectorPRF->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetSumSquare()[nu]) | |
962 | * ((Double_t) ((AliTRDPInfo *) fVectorPRF->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu])) | |
963 | + (((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetSumSquare()[nu]) | |
964 | * ((Double_t) ((AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()))->GetEntries()[nu]))) | |
965 | / ((Double_t) fPInfo->GetEntries()[nu]); | |
966 | ||
967 | sumsquare[nu] = calculsquare; | |
968 | ||
969 | } | |
970 | ||
971 | // Set | |
972 | fPInfo->SetSum(sum); | |
973 | fPInfo->SetSumSquare(sumsquare); | |
974 | fPInfo->SetEntries(entries); | |
975 | ||
976 | // Nothing to do on PlaCT1 | |
977 | ||
978 | // Update the vector VectorCT1 | |
979 | fVectorPRF->AddAt((TObject *) fPInfo,((AliTRDPlace *) fPlaPRF->At(k))->GetPlace()); | |
980 | ||
981 | } | |
982 | ||
983 | } | |
984 | ||
985 | // And at the end the vector in P2 but not in CH1 | |
986 | for (Int_t k = 0; k < (Int_t) pPlaP2->GetEntriesFast(); k++) { | |
987 | ||
988 | // Look if PlaCT2[k] it is also in the second vector | |
989 | Int_t place = -1; | |
990 | for (Int_t j = 0; j < (Int_t) fPlaPRF->GetEntriesFast(); j++) { | |
991 | if (((AliTRDPlace *) fPlaPRF->At(j))->GetPlace() == ((AliTRDPlace *) pPlaP2->At(k))->GetPlace()) { | |
992 | place = j; | |
993 | break; | |
994 | } | |
995 | } | |
996 | ||
997 | // If not in the first vector | |
998 | if (place == -1) { | |
999 | ||
1000 | AliTRDPInfo *fPInfo = new AliTRDPInfo(); | |
1001 | fPInfo = (AliTRDPInfo *) vVectorP2->At(((AliTRDPlace *) pPlaP2->At(k))->GetPlace()); | |
1002 | ||
1003 | // Add at the end of CH1 | |
1004 | fPlaPRF->Add(((TObject *) pPlaP2->At(k))); | |
1005 | fVectorPRF->Add((TObject *) fPInfo); | |
1006 | ||
1007 | } | |
1008 | ||
1009 | } | |
1010 | ||
1011 | } | |
1012 | ||
1013 | return kTRUE; | |
1014 | ||
1015 | } | |
1016 | ||
1017 | //_____________________________________________________________________________ | |
1018 | TTree *AliTRDCalibraVector::Sum2Trees(const Char_t *filename1 | |
1019 | , const Char_t *filename2 | |
1020 | , const Char_t *variablecali) | |
1021 | { | |
1022 | // | |
1023 | // It returns the sum of two trees with the name variablecali | |
1024 | // in the files filenam1 and filename2 equivalent of merging two 2D histos | |
1025 | // The name of the resulting tree is the same as the two input trees | |
1026 | // variablecali can be treeCH2d, treePH2d or treePRF2d | |
1027 | // | |
1028 | ||
1029 | // Variables | |
1030 | TChain *treeChain = new TChain(variablecali); | |
1031 | TObjArray *vectorplace = new TObjArray(); | |
1032 | TObjArray *where = new TObjArray(); | |
1033 | ||
1034 | // First tree | |
1035 | // Take the tree | |
1036 | TFile *file1 = new TFile(filename1,"READ"); | |
1037 | TTree *tree1 = (TTree *) file1->Get(variablecali); | |
1038 | ||
1039 | gDirectory = gROOT; | |
1040 | ||
1041 | // Take the places | |
1042 | vectorplace = ConvertTreeVector(tree1); | |
1043 | ||
1044 | // Say where it is in tree 1 | |
1045 | for (Int_t jui = 0; jui < (Int_t) vectorplace->GetEntriesFast(); jui++) { | |
1046 | AliTRDPlace *placejui = new AliTRDPlace(); | |
1047 | placejui->SetPlace(jui); | |
1048 | TObjArray *chainplace = new TObjArray(); | |
1049 | chainplace->Add((TObject *) placejui); | |
1050 | where->Add((TObject *) chainplace); | |
1051 | } | |
1052 | ||
1053 | // Add to the chain | |
1054 | treeChain->Add(filename1); | |
1055 | delete file1; | |
1056 | ||
1057 | // Second tree | |
1058 | // Take the tree | |
1059 | TFile *file2 = new TFile(filename2,"READ"); | |
1060 | TTree *tree2 = (TTree *) file2->Get(variablecali); | |
1061 | ||
1062 | gDirectory = gROOT; | |
1063 | ||
1064 | // Take the places | |
1065 | TObjArray *vector2 = ConvertTreeVector(tree2); | |
1066 | Int_t j = treeChain->GetEntries(); | |
1067 | ||
1068 | for (Int_t jui = 0; jui < (Int_t) vector2->GetEntriesFast(); jui++) { | |
1069 | // Search if already found | |
1070 | Int_t place = SearchInTreeVector(vectorplace,((AliTRDPlace *) vector2->At(jui))->GetPlace()); | |
1071 | // Create a new element in the two std vectors | |
1072 | if (place == -1) { | |
1073 | AliTRDPlace *placejjui = new AliTRDPlace(); | |
1074 | placejjui->SetPlace((j+jui)); | |
1075 | TObjArray *chainplace = new TObjArray(); | |
1076 | chainplace->Add((TObject *) placejjui); | |
1077 | vectorplace->Add((TObject *) (vector2->At(jui))); | |
1078 | where->Add((TObject *) chainplace); | |
1079 | } | |
1080 | // Update the element at the place "place" in the std vector whereinthechain | |
1081 | else { | |
1082 | AliTRDPlace *placejjui = new AliTRDPlace(); | |
1083 | placejjui->SetPlace((j+jui)); | |
1084 | TObjArray *chainplace = ((TObjArray *) where->At(place)); | |
1085 | chainplace->Add((TObject *) placejjui); | |
1086 | where->AddAt((TObject *) chainplace,place); | |
1087 | } | |
1088 | } | |
1089 | ||
1090 | // Add to the Chain | |
1091 | treeChain->Add(filename2); | |
1092 | delete file2; | |
1093 | ||
1094 | // Take care of the profile | |
1095 | const Char_t *pattern = "P"; | |
1096 | TTree *tree = 0x0; | |
1097 | ||
1098 | if (!strstr(variablecali,pattern)) { | |
1099 | ||
1100 | // Ready to read the chain | |
1101 | TH1F *his = 0x0; | |
1102 | treeChain->SetBranchAddress("histo",&his); | |
1103 | ||
1104 | // Initialise the final tree | |
1105 | Int_t group = -1; | |
1106 | TH1F *histsum = 0x0; | |
1107 | ||
1108 | tree = new TTree(variablecali,variablecali); | |
1109 | tree->Branch("groupnumber",&group,"groupnumber/I"); | |
1110 | tree->Branch("histo","TH1F",&histsum,32000,0); | |
1111 | ||
1112 | // Init histsum | |
1113 | if (treeChain->GetEntries() < 1) { | |
1114 | return tree1; | |
1115 | } | |
1116 | ||
1117 | for (Int_t h = 0; h < (Int_t) vectorplace->GetEntriesFast(); h++) { | |
1118 | group = ((AliTRDPlace *) vectorplace->At(h))->GetPlace(); | |
1119 | TObjArray *chainplace = ((TObjArray *) where->At(h)); | |
1120 | treeChain->GetEntry(((AliTRDPlace *) chainplace->At(0))->GetPlace()); | |
1121 | //Init for the first time | |
1122 | if (h == 0) { | |
1123 | histsum = new TH1F("","",his->GetXaxis()->GetNbins() | |
1124 | ,his->GetXaxis()->GetBinLowEdge(1) | |
1125 | ,his->GetXaxis()->GetBinUpEdge(his->GetXaxis()->GetNbins())); | |
1126 | histsum->Sumw2(); | |
1127 | } | |
1128 | // Reset for each new group | |
1129 | histsum->SetEntries(0.0); | |
1130 | for (Int_t l = 0; l <= histsum->GetXaxis()->GetNbins(); l++) { | |
1131 | histsum->SetBinContent(l,0.0); | |
1132 | histsum->SetBinError(l,0.0); | |
1133 | } | |
1134 | histsum->Add(his,1); | |
1135 | if ((Int_t) chainplace->GetEntriesFast() > 1) { | |
1136 | for (Int_t s = 1; s < (Int_t) chainplace->GetEntriesFast(); s++) { | |
1137 | treeChain->GetEntry(((AliTRDPlace *) chainplace->At(s))->GetPlace()); | |
1138 | histsum->Add(his,1); | |
1139 | } | |
1140 | } | |
1141 | tree->Fill(); | |
1142 | } | |
1143 | ||
1144 | } | |
1145 | else { | |
1146 | ||
1147 | // Ready to read the chain | |
1148 | TGraphErrors *his = 0x0; | |
1149 | treeChain->SetBranchAddress("histo",&his); | |
1150 | ||
1151 | // Initialise the final tree | |
1152 | Int_t group = -1; | |
1153 | TGraphErrors *histsum = 0x0; | |
1154 | Double_t *xref = 0x0; | |
1155 | ||
1156 | tree = new TTree(variablecali,variablecali); | |
1157 | tree->Branch("groupnumber",&group,"groupnumber/I"); | |
1158 | tree->Branch("histo","TGraphErrors",&histsum,32000,0); | |
1159 | ||
1160 | // Init histsum | |
1161 | if (treeChain->GetEntries() < 1) { | |
1162 | return tree1; | |
1163 | } | |
1164 | ||
1165 | for (Int_t h = 0; h < (Int_t) vectorplace->GetEntriesFast(); h++) { | |
1166 | ||
1167 | group = ((AliTRDPlace *) vectorplace->At(h))->GetPlace(); | |
1168 | TObjArray *chainplace = ((TObjArray *) where->At(h)); | |
1169 | treeChain->GetEntry(((AliTRDPlace *) chainplace->At(0))->GetPlace()); | |
1170 | //Init or reset for a new group | |
1171 | Int_t nbins = his->GetN(); | |
1172 | Double_t *x; | |
1173 | x = new Double_t[nbins]; | |
1174 | xref = his->GetX(); | |
1175 | Double_t *ex; | |
1176 | ex = new Double_t[nbins]; | |
1177 | Double_t *y; | |
1178 | y = new Double_t[nbins]; | |
1179 | Double_t *ey; | |
1180 | ey = new Double_t[nbins]; | |
1181 | ||
1182 | for (Int_t lo = 0; lo < nbins; lo++) { | |
1183 | x[lo] = xref[lo]; | |
1184 | ex[lo] = 0.0; | |
1185 | y[lo] = 0.0; | |
1186 | ey[lo] = 0.0; | |
1187 | } | |
1188 | delete histsum; | |
1189 | histsum = new TGraphErrors(nbins,x,y,ex,ey); | |
1190 | ||
1191 | // Add the first | |
1192 | histsum = AddProfiles(his,histsum); | |
1193 | if ((Int_t) chainplace->GetEntriesFast() > 1) { | |
1194 | for (Int_t s = 1; s < (Int_t) chainplace->GetEntriesFast(); s++) { | |
1195 | treeChain->GetEntry(((AliTRDPlace *) chainplace->At(s))->GetPlace()); | |
1196 | histsum = AddProfiles(his,histsum); | |
1197 | } | |
1198 | } | |
1199 | ||
1200 | tree->Fill(); | |
1201 | ||
1202 | } | |
1203 | ||
1204 | } | |
1205 | ||
1206 | return tree; | |
1207 | ||
1208 | } | |
1209 | ||
1210 | //_____________________________________________________________________________ | |
1211 | TGraphErrors *AliTRDCalibraVector::AddProfiles(TGraphErrors *hist1 | |
1212 | , TGraphErrors *hist2) const | |
1213 | { | |
1214 | // | |
1215 | // In the case of the vectors method we use TGraphErrors for PH and PRF | |
1216 | // to be able to add the them after | |
1217 | // Here we add the TGraphErrors | |
1218 | // | |
1219 | ||
1220 | // First TGraphErrors | |
1221 | Int_t nbins1 = hist1->GetN(); | |
1222 | Double_t *x1 = hist1->GetX(); | |
1223 | Double_t *ex1 = hist1->GetEX(); | |
1224 | Double_t *y1 = hist1->GetY(); | |
1225 | Double_t *ey1 = hist1->GetEY(); | |
1226 | ||
1227 | TGraphErrors *rehist = new TGraphErrors(nbins1); | |
1228 | ||
1229 | // Second TGraphErrors | |
1230 | Double_t *ex2 = hist2->GetEX(); | |
1231 | Double_t *y2 = hist2->GetY(); | |
1232 | Double_t *ey2 = hist2->GetEY(); | |
1233 | ||
1234 | // Define the Variables for the new TGraphErrors | |
1235 | Double_t x; | |
1236 | Double_t ex; | |
1237 | Double_t y; | |
1238 | Double_t ey; | |
1239 | ||
1240 | for (Int_t k = 0; k < nbins1; k++) { | |
1241 | Double_t nentries = 0.0; | |
1242 | x = x1[k]; | |
1243 | y = 0.0; | |
1244 | ey = 0.0; | |
1245 | ex = 0.0; | |
1246 | if ((ex2[k] == 0.0) && | |
1247 | (ex1[k] == 0.0)) { | |
1248 | nentries = 0.0; | |
1249 | } | |
1250 | if ((ex2[k] == 0.0) && | |
1251 | (ex1[k] > 0.0)) { | |
1252 | nentries = ex1[k]; | |
1253 | y = y1[k]; | |
1254 | ey = ey1[k]; | |
1255 | ex = ex1[k]; | |
1256 | } | |
1257 | if ((ex2[k] > 0.0) && | |
1258 | (ex1[k] == 0.0)) { | |
1259 | nentries = ex2[k]; | |
1260 | y = y2[k]; | |
1261 | ey = ey2[k]; | |
1262 | ex = ex2[k]; | |
1263 | } | |
1264 | if ((ex2[k] > 0.0) && | |
1265 | (ex1[k] > 0.0)) { | |
1266 | nentries = ex1[k] + ex2[k]; | |
1267 | y = ( y1[k]*ex1[k]+ y2[k]*ex2[k]) / nentries; | |
1268 | ey = (ey1[k]*ex1[k]+ey2[k]*ex2[k]) / nentries; | |
1269 | ex = nentries; | |
1270 | } | |
1271 | rehist->SetPoint(k,x,y); | |
1272 | rehist->SetPointError(k,ex,ey); | |
1273 | } | |
1274 | ||
1275 | return rehist; | |
1276 | ||
1277 | } |