]>
Commit | Line | Data |
---|---|---|
b3fcfd96 | 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 | ||
18 | /* | |
4c865c34 | 19 | Responsible: Raphaelle Bailhache (rbailhache@ikf.uni-frankfurt.de) |
20 | Code to analyze the TRD calibration and to produce OCDB entries | |
b3fcfd96 | 21 | |
22 | ||
23 | .x ~/rootlogon.C | |
24 | gSystem->Load("libANALYSIS"); | |
4c865c34 | 25 | gSystem->Load("libTRDcalib"); |
b3fcfd96 | 26 | |
27 | AliTRDPreprocessorOffline proces; | |
28 | TString ocdbPath="local:////" | |
29 | ocdbPath+=gSystem->GetFromPipe("pwd"); | |
30 | ||
31 | proces.CalibTimeGain("CalibObjects.root",run0,run1,ocdbPath); | |
32 | proces.CalibTimeVdrift("CalibObjects.root",run0,run1,ocdbPath); | |
33 | // take the raw calibration data from the file CalibObjects.root | |
34 | // and make a OCDB entry with run validity run0-run1 | |
35 | // results are stored at the ocdbPath - local or alien ... | |
36 | // default storage ""- data stored at current working directory | |
37 | ||
38 | */ | |
00d203b6 | 39 | #include "AliLog.h" |
b3fcfd96 | 40 | #include "Riostream.h" |
41 | #include <fstream> | |
42 | #include "TFile.h" | |
43 | #include "TCanvas.h" | |
44 | #include "TLegend.h" | |
45 | #include "TH2I.h" | |
46 | #include "TH1I.h" | |
47 | #include "TH2F.h" | |
48 | #include "TH1F.h" | |
49 | #include "TProfile2D.h" | |
50 | #include "AliTRDCalDet.h" | |
51 | #include "AliTRDCalPad.h" | |
52 | #include "AliCDBMetaData.h" | |
53 | #include "AliCDBId.h" | |
54 | #include "AliCDBManager.h" | |
55 | #include "AliCDBStorage.h" | |
56 | #include "AliTRDCalibraMode.h" | |
57 | #include "AliTRDCalibraFit.h" | |
58 | #include "AliTRDCalibraVdriftLinearFit.h" | |
59 | #include "AliTRDPreprocessorOffline.h" | |
81a5aeca | 60 | #include "AliTRDCalChamberStatus.h" |
b3fcfd96 | 61 | |
62 | ||
63 | ClassImp(AliTRDPreprocessorOffline) | |
64 | ||
65 | AliTRDPreprocessorOffline::AliTRDPreprocessorOffline(): | |
01239968 | 66 | TNamed("TPCPreprocessorOffline","TPCPreprocessorOffline"), |
b3fcfd96 | 67 | fMethodSecond(kTRUE), |
01239968 | 68 | fNameList("TRDCalib"), |
69 | fCalDetGainUsed(0x0), | |
4c865c34 | 70 | fCalDetVdriftUsed(0x0), |
b3fcfd96 | 71 | fCH2d(0x0), |
72 | fPH2d(0x0), | |
73 | fPRF2d(0x0), | |
74 | fAliTRDCalibraVdriftLinearFit(0x0), | |
75 | fNEvents(0x0), | |
76 | fAbsoluteGain(0x0), | |
77 | fPlots(new TObjArray(8)), | |
4c865c34 | 78 | fCalibObjects(new TObjArray(8)), |
79 | fVersionGainUsed(0), | |
80 | fSubVersionGainUsed(0), | |
81 | fVersionVdriftUsed(0), | |
00d203b6 | 82 | fSubVersionVdriftUsed(0), |
83 | fSwitchOnValidation(kTRUE), | |
84 | fVdriftValidated(kFALSE), | |
a2a4ec8e | 85 | fT0Validated(kFALSE), |
86 | fMinStatsVdriftT0PH(800*20), | |
87 | fMinStatsVdriftLinear(800), | |
88 | fMinStatsGain(800), | |
89 | fMinStatsPRF(600) | |
b3fcfd96 | 90 | { |
91 | // | |
92 | // default constructor | |
93 | // | |
94 | } | |
00d203b6 | 95 | //_________________________________________________________________________________________________________________ |
b3fcfd96 | 96 | AliTRDPreprocessorOffline::~AliTRDPreprocessorOffline() { |
97 | // | |
98 | // Destructor | |
99 | // | |
100 | ||
01239968 | 101 | if(fCalDetGainUsed) delete fCalDetGainUsed; |
4c865c34 | 102 | if(fCalDetVdriftUsed) delete fCalDetVdriftUsed; |
b3fcfd96 | 103 | if(fCH2d) delete fCH2d; |
104 | if(fPH2d) delete fPH2d; | |
105 | if(fPRF2d) delete fPRF2d; | |
106 | if(fAliTRDCalibraVdriftLinearFit) delete fAliTRDCalibraVdriftLinearFit; | |
107 | if(fNEvents) delete fNEvents; | |
108 | if(fAbsoluteGain) delete fAbsoluteGain; | |
109 | if(fPlots) delete fPlots; | |
110 | if(fCalibObjects) delete fCalibObjects; | |
111 | ||
112 | } | |
00d203b6 | 113 | //___________________________________________________________________________________________________________________ |
b3fcfd96 | 114 | |
115 | void AliTRDPreprocessorOffline::CalibVdriftT0(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ | |
116 | // | |
117 | // make calibration of the drift velocity | |
118 | // Input parameters: | |
119 | // file - the location of input file | |
120 | // startRunNumber, endRunNumber - run validity period | |
121 | // ocdbStorage - path to the OCDB storage | |
122 | // - if empty - local storage 'pwd' uesed | |
123 | if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; | |
124 | // | |
125 | // 1. Initialization | |
126 | // | |
008817a3 | 127 | fVdriftValidated = kTRUE; |
128 | fT0Validated = kTRUE; | |
b3fcfd96 | 129 | // |
130 | // 2. extraction of the information | |
131 | // | |
132 | if(ReadVdriftT0Global(file)) AnalyzeVdriftT0(); | |
133 | if(ReadVdriftLinearFitGlobal(file)) AnalyzeVdriftLinearFit(); | |
134 | // | |
135 | // 3. Append QA plots | |
136 | // | |
137 | //MakeDefaultPlots(fVdriftArray,fVdriftArray); | |
138 | // | |
139 | // | |
00d203b6 | 140 | // 4. validate OCDB entries |
b3fcfd96 | 141 | // |
00d203b6 | 142 | if(fSwitchOnValidation==kTRUE && ValidateVdrift()==kFALSE) { |
143 | AliError("TRD vdrift OCDB parameters out of range!"); | |
144 | fVdriftValidated = kFALSE; | |
145 | } | |
146 | if(fSwitchOnValidation==kTRUE && ValidateT0()==kFALSE) { | |
147 | AliError("TRD t0 OCDB parameters out of range!"); | |
148 | fT0Validated = kFALSE; | |
149 | } | |
b3fcfd96 | 150 | // |
00d203b6 | 151 | // 5. update of OCDB |
152 | // | |
153 | // | |
154 | if(fVdriftValidated) UpdateOCDBVdrift(startRunNumber,endRunNumber,ocdbStorage); | |
155 | if(fT0Validated) UpdateOCDBT0(startRunNumber,endRunNumber,ocdbStorage); | |
156 | ||
b3fcfd96 | 157 | } |
00d203b6 | 158 | //_________________________________________________________________________________________________________________ |
b3fcfd96 | 159 | |
160 | void AliTRDPreprocessorOffline::CalibGain(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ | |
161 | // | |
162 | // make calibration of the drift velocity | |
163 | // Input parameters: | |
164 | // file - the location of input file | |
165 | // startRunNumber, endRunNumber - run validity period | |
166 | // ocdbStorage - path to the OCDB storage | |
167 | // - if empty - local storage 'pwd' uesed | |
168 | if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; | |
169 | // | |
170 | // 1. Initialization | |
171 | if(!ReadGainGlobal(file)) return; | |
172 | // | |
173 | // | |
174 | // 2. extraction of the information | |
175 | // | |
176 | AnalyzeGain(); | |
01239968 | 177 | if(fCalDetGainUsed) CorrectFromDetGainUsed(); |
4c865c34 | 178 | if(fCalDetVdriftUsed) CorrectFromDetVdriftUsed(); |
b3fcfd96 | 179 | // |
180 | // 3. Append QA plots | |
181 | // | |
182 | //MakeDefaultPlots(fVdriftArray,fVdriftArray); | |
183 | // | |
184 | // | |
00d203b6 | 185 | // 4. validate OCDB entries |
186 | // | |
187 | if(fSwitchOnValidation==kTRUE && ValidateGain()==kFALSE) { | |
188 | AliError("TRD gain OCDB parameters out of range!"); | |
189 | return; | |
190 | } | |
b3fcfd96 | 191 | // |
00d203b6 | 192 | // 5. update of OCDB |
b3fcfd96 | 193 | // |
00d203b6 | 194 | // |
195 | if((!fCalDetVdriftUsed) || (fCalDetVdriftUsed && fVdriftValidated)) UpdateOCDBGain(startRunNumber,endRunNumber,ocdbStorage); | |
196 | ||
b3fcfd96 | 197 | |
198 | } | |
00d203b6 | 199 | //________________________________________________________________________________________________________________ |
b3fcfd96 | 200 | |
201 | void AliTRDPreprocessorOffline::CalibPRF(const Char_t* file, Int_t startRunNumber, Int_t endRunNumber, TString ocdbStorage){ | |
202 | // | |
203 | // make calibration of the drift velocity | |
204 | // Input parameters: | |
205 | // file - the location of input file | |
206 | // startRunNumber, endRunNumber - run validity period | |
207 | // ocdbStorage - path to the OCDB storage | |
208 | // - if empty - local storage 'pwd' uesed | |
209 | if (ocdbStorage.Length()<=0) ocdbStorage="local://"+gSystem->GetFromPipe("pwd")+"/OCDB"; | |
210 | // | |
211 | // 1. Initialization | |
212 | if(!ReadPRFGlobal(file)) return; | |
213 | // | |
214 | // | |
215 | // 2. extraction of the information | |
216 | // | |
217 | AnalyzePRF(); | |
218 | // | |
219 | // 3. Append QA plots | |
220 | // | |
221 | //MakeDefaultPlots(fVdriftArray,fVdriftArray); | |
222 | // | |
223 | // | |
00d203b6 | 224 | // |
225 | // 4. validate OCDB entries | |
226 | // | |
227 | if(fSwitchOnValidation==kTRUE && ValidatePRF()==kFALSE) { | |
228 | AliError("TRD prf OCDB parameters out of range!"); | |
229 | return; | |
230 | } | |
231 | // | |
232 | // 5. update of OCDB | |
b3fcfd96 | 233 | // |
234 | // | |
235 | UpdateOCDBPRF(startRunNumber,endRunNumber,ocdbStorage); | |
236 | ||
237 | } | |
00d203b6 | 238 | //______________________________________________________________________________________________________ |
4c865c34 | 239 | Bool_t AliTRDPreprocessorOffline::Init(const Char_t* fileName){ |
240 | // | |
241 | // read the calibration used during the reconstruction | |
242 | // | |
243 | ||
244 | if(ReadVdriftT0Global(fileName)) { | |
245 | ||
246 | TString nameph = fPH2d->GetTitle(); | |
247 | fVersionVdriftUsed = GetVersion(nameph); | |
248 | fSubVersionVdriftUsed = GetSubVersion(nameph); | |
249 | ||
250 | //printf("Found Version %d, Subversion %d for vdrift\n",fVersionVdriftUsed,fSubVersionVdriftUsed); | |
251 | ||
252 | } | |
253 | ||
254 | if(ReadGainGlobal(fileName)) { | |
255 | ||
256 | TString namech = fCH2d->GetTitle(); | |
257 | fVersionGainUsed = GetVersion(namech); | |
258 | fSubVersionGainUsed = GetSubVersion(namech); | |
259 | ||
260 | //printf("Found Version %d, Subversion %d for gain\n",fVersionGainUsed,fSubVersionGainUsed); | |
261 | ||
262 | } | |
263 | ||
264 | return kTRUE; | |
265 | ||
266 | } | |
00d203b6 | 267 | //___________________________________________________________________________________________________________________ |
b3fcfd96 | 268 | |
269 | Bool_t AliTRDPreprocessorOffline::ReadGainGlobal(const Char_t* fileName){ | |
270 | // | |
271 | // read calibration entries from file | |
272 | // | |
4c865c34 | 273 | if(fCH2d) return kTRUE; |
b3fcfd96 | 274 | TFile fcalib(fileName); |
01239968 | 275 | TObjArray * array = (TObjArray*)fcalib.Get(fNameList); |
b3fcfd96 | 276 | if (array){ |
277 | TH2I *ch2d = (TH2I *) array->FindObject("CH2d"); | |
278 | if(!ch2d) return kFALSE; | |
279 | fCH2d = (TH2I*)ch2d->Clone(); | |
280 | //fNEvents = (TH1I *) array->FindObject("NEvents"); | |
281 | //fAbsoluteGain = (TH2F *) array->FindObject("AbsoluteGain"); | |
282 | }else{ | |
283 | TH2I *ch2d = (TH2I *) fcalib.Get("CH2d"); | |
284 | if(!ch2d) return kFALSE; | |
285 | fCH2d = (TH2I*)ch2d->Clone(); | |
286 | //fNEvents = (TH1I *) fcalib.Get("NEvents"); | |
287 | //fAbsoluteGain = (TH2F *) fcalib.Get("AbsoluteGain"); | |
288 | } | |
289 | fCH2d->SetDirectory(0); | |
290 | //printf("title of CH2d %s\n",fCH2d->GetTitle()); | |
291 | ||
292 | return kTRUE; | |
293 | ||
294 | } | |
00d203b6 | 295 | //_________________________________________________________________________________________________________________ |
b3fcfd96 | 296 | |
297 | Bool_t AliTRDPreprocessorOffline::ReadVdriftT0Global(const Char_t* fileName){ | |
298 | // | |
299 | // read calibration entries from file | |
300 | // | |
4c865c34 | 301 | if(fPH2d) return kTRUE; |
b3fcfd96 | 302 | TFile fcalib(fileName); |
01239968 | 303 | TObjArray * array = (TObjArray*)fcalib.Get(fNameList); |
b3fcfd96 | 304 | if (array){ |
305 | TProfile2D *ph2d = (TProfile2D *) array->FindObject("PH2d"); | |
306 | if(!ph2d) return kFALSE; | |
307 | fPH2d = (TProfile2D*)ph2d->Clone(); | |
308 | //fNEvents = (TH1I *) array->FindObject("NEvents"); | |
309 | }else{ | |
310 | TProfile2D *ph2d = (TProfile2D *) fcalib.Get("PH2d"); | |
311 | if(!ph2d) return kFALSE; | |
312 | fPH2d = (TProfile2D*)ph2d->Clone(); | |
313 | //fNEvents = (TH1I *) fcalib.Get("NEvents"); | |
314 | } | |
315 | fPH2d->SetDirectory(0); | |
316 | //printf("title of PH2d %s\n",fPH2d->GetTitle()); | |
317 | ||
318 | return kTRUE; | |
319 | ||
320 | } | |
00d203b6 | 321 | //___________________________________________________________________________________________________________________ |
b3fcfd96 | 322 | |
323 | Bool_t AliTRDPreprocessorOffline::ReadVdriftLinearFitGlobal(const Char_t* fileName){ | |
324 | // | |
325 | // read calibration entries from file | |
326 | // | |
4c865c34 | 327 | if(fAliTRDCalibraVdriftLinearFit) return kTRUE; |
b3fcfd96 | 328 | TFile fcalib(fileName); |
01239968 | 329 | TObjArray * array = (TObjArray*)fcalib.Get(fNameList); |
b3fcfd96 | 330 | if (array){ |
331 | fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) array->FindObject("AliTRDCalibraVdriftLinearFit"); | |
332 | //fNEvents = (TH1I *) array->FindObject("NEvents"); | |
333 | }else{ | |
334 | fAliTRDCalibraVdriftLinearFit = (AliTRDCalibraVdriftLinearFit *) fcalib.Get("AliTRDCalibraVdriftLinearFit"); | |
335 | //fNEvents = (TH1I *) fcalib.Get("NEvents"); | |
336 | } | |
337 | if(!fAliTRDCalibraVdriftLinearFit) { | |
338 | //printf("No AliTRDCalibraVdriftLinearFit\n"); | |
339 | return kFALSE; | |
340 | } | |
341 | return kTRUE; | |
342 | ||
343 | } | |
00d203b6 | 344 | //_____________________________________________________________________________________________________________ |
b3fcfd96 | 345 | |
346 | Bool_t AliTRDPreprocessorOffline::ReadPRFGlobal(const Char_t* fileName){ | |
347 | // | |
348 | // read calibration entries from file | |
349 | // | |
4c865c34 | 350 | if(fPRF2d) return kTRUE; |
b3fcfd96 | 351 | TFile fcalib(fileName); |
01239968 | 352 | TObjArray * array = (TObjArray*)fcalib.Get(fNameList); |
b3fcfd96 | 353 | if (array){ |
354 | TProfile2D *prf2d = (TProfile2D *) array->FindObject("PRF2d"); | |
355 | if(!prf2d) return kFALSE; | |
356 | fPRF2d = (TProfile2D*)prf2d->Clone(); | |
357 | //fNEvents = (TH1I *) array->FindObject("NEvents"); | |
358 | }else{ | |
359 | TProfile2D *prf2d = (TProfile2D *) fcalib.Get("PRF2d"); | |
360 | if(!prf2d) return kFALSE; | |
361 | fPRF2d = (TProfile2D*)prf2d->Clone(); | |
362 | //fNEvents = (TH1I *) fcalib.Get("NEvents"); | |
363 | } | |
364 | fPRF2d->SetDirectory(0); | |
365 | //printf("title of PRF2d %s\n",fPRF2d->GetTitle()); | |
366 | ||
367 | return kTRUE; | |
368 | ||
369 | } | |
00d203b6 | 370 | //__________________________________________________________________________________________________________ |
b3fcfd96 | 371 | |
372 | Bool_t AliTRDPreprocessorOffline::AnalyzeGain(){ | |
373 | // | |
374 | // Analyze gain - produce the calibration objects | |
375 | // | |
376 | ||
377 | AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); | |
a2a4ec8e | 378 | calibra->SetMinEntries(fMinStatsGain); // If there is less than 1000 entries in the histo: no fit |
b3fcfd96 | 379 | calibra->AnalyseCH(fCH2d); |
380 | ||
381 | Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(0)) | |
382 | + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(0)); | |
383 | Int_t nbfit = calibra->GetNumberFit(); | |
384 | Int_t nbE = calibra->GetNumberEnt(); | |
385 | ||
386 | ||
387 | Bool_t ok = kFALSE; | |
4c865c34 | 388 | Bool_t meanother = kFALSE; |
b3fcfd96 | 389 | // enough statistics |
390 | if ((nbtg > 0) && | |
391 | (nbfit >= 0.5*nbE) && (nbE > 30)) { | |
392 | // create the cal objects | |
4c865c34 | 393 | if(!fCalDetGainUsed) { |
394 | calibra->PutMeanValueOtherVectorFit(1,kTRUE); | |
395 | meanother = kTRUE; | |
396 | } | |
b3fcfd96 | 397 | TObjArray object = calibra->GetVectorFit(); |
4c865c34 | 398 | AliTRDCalDet *calDetGain = calibra->CreateDetObjectGain(&object,meanother); |
b3fcfd96 | 399 | TH1F *coefGain = calDetGain->MakeHisto1DAsFunctionOfDet(); |
400 | // Put them in the array | |
401 | fCalibObjects->AddAt(calDetGain,kGain); | |
402 | fPlots->AddAt(coefGain,kGain); | |
403 | // | |
404 | ok = kTRUE; | |
405 | } | |
406 | ||
407 | calibra->ResetVectorFit(); | |
408 | ||
409 | return ok; | |
410 | ||
411 | } | |
00d203b6 | 412 | //_____________________________________________________________________________________________________ |
b3fcfd96 | 413 | Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftT0(){ |
414 | // | |
415 | // Analyze VdriftT0 - produce the calibration objects | |
416 | // | |
417 | ||
418 | AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); | |
a2a4ec8e | 419 | calibra->SetMinEntries(fMinStatsVdriftT0PH); // If there is less than 1000 entries in the histo: no fit |
b3fcfd96 | 420 | calibra->AnalysePH(fPH2d); |
421 | ||
422 | Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(1)) | |
423 | + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(1)); | |
424 | Int_t nbfit = calibra->GetNumberFit(); | |
425 | Int_t nbfitSuccess = calibra->GetNumberFitSuccess(); | |
426 | Int_t nbE = calibra->GetNumberEnt(); | |
427 | ||
428 | //printf("nbtg %d, nbfit %d, nbE %d, nbfitSuccess %d\n",nbtg,nbfit,nbE,nbfitSuccess); | |
429 | ||
430 | Bool_t ok = kFALSE; | |
431 | if ((nbtg > 0) && | |
432 | (nbfit >= 0.5*nbE) && (nbE > 30) && (nbfitSuccess > 30)) { | |
433 | //printf("Pass the cut for VdriftT0\n"); | |
434 | // create the cal objects | |
01239968 | 435 | calibra->RemoveOutliers(1,kFALSE); |
436 | calibra->PutMeanValueOtherVectorFit(1,kFALSE); | |
437 | calibra->RemoveOutliers2(kFALSE); | |
438 | calibra->PutMeanValueOtherVectorFit2(1,kFALSE); | |
439 | // | |
b3fcfd96 | 440 | TObjArray object = calibra->GetVectorFit(); |
441 | AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object); | |
442 | TH1F *coefVdriftPH = calDetVdrift->MakeHisto1DAsFunctionOfDet(); | |
443 | AliTRDCalPad *calPadVdrift = (AliTRDCalPad *)calibra->CreatePadObjectVdrift(&object,calDetVdrift); | |
444 | TH1F *coefPadVdrift = calPadVdrift->MakeHisto1D(); | |
445 | object = calibra->GetVectorFit2(); | |
446 | AliTRDCalDet *calDetT0 = calibra->CreateDetObjectT0(&object); | |
447 | TH1F *coefT0 = calDetT0->MakeHisto1DAsFunctionOfDet(); | |
448 | AliTRDCalPad *calPadT0 = (AliTRDCalPad *)calibra->CreatePadObjectT0(&object,calDetT0); | |
449 | TH1F *coefPadT0 = calPadT0->MakeHisto1D(); | |
450 | // Put them in the array | |
451 | fCalibObjects->AddAt(calDetT0,kT0PHDet); | |
452 | fCalibObjects->AddAt(calDetVdrift,kVdriftPHDet); | |
453 | fCalibObjects->AddAt(calPadT0,kT0PHPad); | |
454 | fCalibObjects->AddAt(calPadVdrift,kVdriftPHPad); | |
455 | fPlots->AddAt(coefVdriftPH,kVdriftPHDet); | |
456 | fPlots->AddAt(coefT0,kT0PHDet); | |
457 | fPlots->AddAt(coefPadVdrift,kVdriftPHPad); | |
458 | fPlots->AddAt(coefPadT0,kT0PHPad); | |
459 | // | |
460 | ok = kTRUE; | |
461 | } | |
462 | calibra->ResetVectorFit(); | |
463 | ||
464 | return ok; | |
465 | ||
466 | } | |
00d203b6 | 467 | //____________________________________________________________________________________________________________________ |
b3fcfd96 | 468 | Bool_t AliTRDPreprocessorOffline::AnalyzeVdriftLinearFit(){ |
469 | // | |
470 | // Analyze vdrift linear fit - produce the calibration objects | |
471 | // | |
472 | ||
473 | AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); | |
a2a4ec8e | 474 | calibra->SetMinEntries(fMinStatsVdriftLinear); // If there is less than 1000 entries in the histo: no fit |
01239968 | 475 | fAliTRDCalibraVdriftLinearFit->FillPEArray(); |
b3fcfd96 | 476 | calibra->AnalyseLinearFitters(fAliTRDCalibraVdriftLinearFit); |
477 | ||
478 | //Int_t nbtg = 540; | |
479 | Int_t nbfit = calibra->GetNumberFit(); | |
480 | Int_t nbE = calibra->GetNumberEnt(); | |
481 | ||
482 | ||
483 | Bool_t ok = kFALSE; | |
484 | // enough statistics | |
485 | if ((nbfit >= 0.5*nbE) && (nbE > 30)) { | |
486 | // create the cal objects | |
01239968 | 487 | //calibra->RemoveOutliers(1,kTRUE); |
488 | calibra->PutMeanValueOtherVectorFit(1,kTRUE); | |
489 | //calibra->RemoveOutliers2(kTRUE); | |
490 | calibra->PutMeanValueOtherVectorFit2(1,kTRUE); | |
491 | // | |
b3fcfd96 | 492 | TObjArray object = calibra->GetVectorFit(); |
493 | AliTRDCalDet *calDetVdrift = calibra->CreateDetObjectVdrift(&object,kTRUE); | |
494 | TH1F *coefDriftLinear = calDetVdrift->MakeHisto1DAsFunctionOfDet(); | |
495 | object = calibra->GetVectorFit2(); | |
496 | AliTRDCalDet *calDetLorentz = calibra->CreateDetObjectLorentzAngle(&object); | |
497 | TH1F *coefLorentzAngle = calDetLorentz->MakeHisto1DAsFunctionOfDet(); | |
498 | // Put them in the array | |
499 | fCalibObjects->AddAt(calDetVdrift,kVdriftLinear); | |
500 | fCalibObjects->AddAt(calDetLorentz,kLorentzLinear); | |
501 | fPlots->AddAt(coefDriftLinear,kVdriftLinear); | |
502 | fPlots->AddAt(coefLorentzAngle,kLorentzLinear); | |
503 | // | |
504 | ok = kTRUE; | |
505 | } | |
506 | ||
507 | calibra->ResetVectorFit(); | |
508 | ||
509 | return ok; | |
510 | ||
511 | } | |
00d203b6 | 512 | //________________________________________________________________________________________________________________ |
b3fcfd96 | 513 | |
514 | Bool_t AliTRDPreprocessorOffline::AnalyzePRF(){ | |
515 | // | |
516 | // Analyze PRF - produce the calibration objects | |
517 | // | |
518 | ||
519 | AliTRDCalibraFit *calibra = AliTRDCalibraFit::Instance(); | |
a2a4ec8e | 520 | calibra->SetMinEntries(fMinStatsPRF); // If there is less than 1000 entries in the histo: no fit |
b3fcfd96 | 521 | calibra->AnalysePRFMarianFit(fPRF2d); |
522 | ||
523 | Int_t nbtg = 6*4*18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb0(2)) | |
524 | + 6* 18*((Int_t) ((AliTRDCalibraMode *)calibra->GetCalibraMode())->GetDetChamb2(2)); | |
525 | Int_t nbfit = calibra->GetNumberFit(); | |
526 | Int_t nbE = calibra->GetNumberEnt(); | |
527 | ||
528 | ||
529 | Bool_t ok = kFALSE; | |
530 | // enough statistics | |
531 | if ((nbtg > 0) && | |
532 | (nbfit >= 0.95*nbE) && (nbE > 30)) { | |
533 | // create the cal objects | |
534 | TObjArray object = calibra->GetVectorFit(); | |
535 | AliTRDCalPad *calPadPRF = (AliTRDCalPad*) calibra->CreatePadObjectPRF(&object); | |
536 | TH1F *coefPRF = calPadPRF->MakeHisto1D(); | |
537 | // Put them in the array | |
538 | fCalibObjects->AddAt(calPadPRF,kPRF); | |
539 | fPlots->AddAt(coefPRF,kPRF); | |
540 | // | |
541 | ok = kTRUE; | |
542 | } | |
543 | ||
544 | calibra->ResetVectorFit(); | |
545 | ||
546 | return ok; | |
547 | ||
548 | } | |
00d203b6 | 549 | //________________________________________________________________________________________________ |
01239968 | 550 | void AliTRDPreprocessorOffline::CorrectFromDetGainUsed() { |
4c865c34 | 551 | // |
552 | // Correct from the gas gain used afterwards | |
553 | // | |
01239968 | 554 | AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain); |
555 | if(!calDetGain) return; | |
556 | ||
4c865c34 | 557 | // Calculate mean |
558 | Double_t mean = 0.0; | |
559 | Int_t nbdet = 0; | |
560 | ||
01239968 | 561 | for(Int_t det = 0; det < 540; det++) { |
562 | ||
563 | Float_t gaininit = fCalDetGainUsed->GetValue(det); | |
564 | Float_t gainout = calDetGain->GetValue(det); | |
01239968 | 565 | |
4c865c34 | 566 | |
567 | if(TMath::Abs(gainout-1.0) > 0.000001) { | |
568 | mean += (gaininit*gainout); | |
569 | nbdet++; | |
570 | } | |
571 | } | |
572 | if(nbdet > 0) mean = mean/nbdet; | |
573 | ||
574 | for(Int_t det = 0; det < 540; det++) { | |
575 | ||
576 | Float_t gaininit = fCalDetGainUsed->GetValue(det); | |
577 | Float_t gainout = calDetGain->GetValue(det); | |
578 | ||
579 | if(TMath::Abs(gainout-1.0) > 0.000001) calDetGain->SetValue(det,gaininit*gainout); | |
580 | else calDetGain->SetValue(det,mean); | |
01239968 | 581 | } |
582 | ||
583 | ||
584 | } | |
00d203b6 | 585 | //________________________________________________________________________________________________ |
4c865c34 | 586 | void AliTRDPreprocessorOffline::CorrectFromDetVdriftUsed() { |
587 | // | |
588 | // Correct from the drift velocity | |
589 | // | |
590 | ||
591 | //printf("Correct for vdrift\n"); | |
592 | ||
593 | AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain); | |
594 | if(!calDetGain) return; | |
595 | ||
596 | Int_t detVdrift = kVdriftPHDet; | |
597 | if(fMethodSecond) detVdrift = kVdriftLinear; | |
598 | AliTRDCalDet *calDetVdrift = (AliTRDCalDet *) fCalibObjects->At(detVdrift); | |
599 | if(!calDetVdrift) return; | |
600 | ||
601 | // Calculate mean | |
602 | ||
603 | for(Int_t det = 0; det < 540; det++) { | |
604 | ||
605 | Float_t vdriftinit = fCalDetVdriftUsed->GetValue(det); | |
606 | Float_t vdriftout = calDetVdrift->GetValue(det); | |
607 | ||
608 | Float_t gain = calDetGain->GetValue(det); | |
609 | if(vdriftout > 0.0) gain = gain*vdriftinit/vdriftout; | |
610 | calDetGain->SetValue(det,gain); | |
611 | ||
612 | ||
613 | } | |
614 | ||
615 | } | |
00d203b6 | 616 | //_________________________________________________________________________________________________________________ |
b3fcfd96 | 617 | void AliTRDPreprocessorOffline::UpdateOCDBGain(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ |
618 | // | |
619 | // Update OCDB entry | |
620 | // | |
621 | ||
622 | AliCDBMetaData *metaData= new AliCDBMetaData(); | |
623 | metaData->SetObjectClassName("AliTRDCalDet"); | |
624 | metaData->SetResponsible("Raphaelle Bailhache"); | |
625 | metaData->SetBeamPeriod(1); | |
626 | ||
627 | AliCDBId id1("TRD/Calib/ChamberGainFactor", startRunNumber, endRunNumber); | |
628 | AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); | |
629 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain); | |
630 | if(calDet) gStorage->Put(calDet, id1, metaData); | |
b3fcfd96 | 631 | |
632 | ||
633 | } | |
00d203b6 | 634 | //___________________________________________________________________________________________________________________ |
b3fcfd96 | 635 | void AliTRDPreprocessorOffline::UpdateOCDBVdrift(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ |
636 | // | |
637 | // Update OCDB entry | |
638 | // | |
639 | ||
640 | Int_t detVdrift = kVdriftPHDet; | |
641 | ||
642 | if(fMethodSecond) detVdrift = kVdriftLinear; | |
643 | ||
644 | AliCDBMetaData *metaData= new AliCDBMetaData(); | |
645 | metaData->SetObjectClassName("AliTRDCalDet"); | |
646 | metaData->SetResponsible("Raphaelle Bailhache"); | |
647 | metaData->SetBeamPeriod(1); | |
648 | ||
649 | AliCDBId id1("TRD/Calib/ChamberVdrift", startRunNumber, endRunNumber); | |
650 | AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); | |
651 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift); | |
652 | if(calDet) gStorage->Put(calDet, id1, metaData); | |
4c865c34 | 653 | |
b3fcfd96 | 654 | // |
655 | ||
656 | if(!fMethodSecond) { | |
657 | ||
658 | AliCDBMetaData *metaDataPad= new AliCDBMetaData(); | |
659 | metaDataPad->SetObjectClassName("AliTRDCalPad"); | |
660 | metaDataPad->SetResponsible("Raphaelle Bailhache"); | |
661 | metaDataPad->SetBeamPeriod(1); | |
662 | ||
663 | AliCDBId id1Pad("TRD/Calib/LocalVdrift", startRunNumber, endRunNumber); | |
664 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad); | |
665 | if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad); | |
4c865c34 | 666 | |
b3fcfd96 | 667 | } |
668 | ||
669 | } | |
00d203b6 | 670 | //________________________________________________________________________________________________________________________ |
b3fcfd96 | 671 | void AliTRDPreprocessorOffline::UpdateOCDBT0(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ |
672 | // | |
673 | // Update OCDB entry | |
674 | // | |
675 | ||
676 | AliCDBMetaData *metaData= new AliCDBMetaData(); | |
677 | metaData->SetObjectClassName("AliTRDCalDet"); | |
678 | metaData->SetResponsible("Raphaelle Bailhache"); | |
679 | metaData->SetBeamPeriod(1); | |
680 | ||
681 | AliCDBId id1("TRD/Calib/ChamberT0", startRunNumber, endRunNumber); | |
682 | AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); | |
683 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet); | |
684 | if(calDet) gStorage->Put(calDet, id1, metaData); | |
b3fcfd96 | 685 | |
b3fcfd96 | 686 | // |
687 | ||
688 | AliCDBMetaData *metaDataPad= new AliCDBMetaData(); | |
689 | metaDataPad->SetObjectClassName("AliTRDCalPad"); | |
690 | metaDataPad->SetResponsible("Raphaelle Bailhache"); | |
691 | metaDataPad->SetBeamPeriod(1); | |
692 | ||
693 | AliCDBId id1Pad("TRD/Calib/LocalT0", startRunNumber, endRunNumber); | |
694 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad); | |
695 | if(calPad) gStorage->Put(calPad, id1Pad, metaDataPad); | |
4c865c34 | 696 | |
b3fcfd96 | 697 | |
698 | ||
699 | } | |
00d203b6 | 700 | //_________________________________________________________________________________________________________________ |
b3fcfd96 | 701 | void AliTRDPreprocessorOffline::UpdateOCDBPRF(Int_t startRunNumber, Int_t endRunNumber, const Char_t *storagePath){ |
702 | // | |
703 | // Update OCDB entry | |
704 | // | |
705 | ||
706 | AliCDBMetaData *metaData= new AliCDBMetaData(); | |
707 | metaData->SetObjectClassName("AliTRDCalPad"); | |
708 | metaData->SetResponsible("Raphaelle Bailhache"); | |
709 | metaData->SetBeamPeriod(1); | |
710 | ||
711 | AliCDBId id1("TRD/Calib/PRFWidth", startRunNumber, endRunNumber); | |
712 | AliCDBStorage * gStorage = AliCDBManager::Instance()->GetStorage(storagePath); | |
713 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF); | |
714 | if(calPad) gStorage->Put(calPad, id1, metaData); | |
b3fcfd96 | 715 | |
716 | ||
00d203b6 | 717 | } |
718 | //__________________________________________________________________________________________________________________________ | |
719 | Bool_t AliTRDPreprocessorOffline::ValidateGain() const { | |
720 | // | |
721 | // Validate OCDB entry | |
722 | // | |
723 | ||
724 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kGain); | |
725 | if(calDet) { | |
726 | Double_t mean = calDet->GetMean(); | |
727 | Double_t rms = calDet->GetRMS(); | |
728 | if((mean > 0.2) && (mean < 1.4) && (rms < 0.5)) return kTRUE; | |
729 | else return kFALSE; | |
730 | } | |
731 | else return kFALSE; | |
732 | ||
733 | ||
734 | } | |
735 | //__________________________________________________________________________________________________________________________ | |
736 | Bool_t AliTRDPreprocessorOffline::ValidateVdrift(){ | |
737 | // | |
738 | // Update OCDB entry | |
739 | // | |
740 | ||
741 | Int_t detVdrift = kVdriftPHDet; | |
742 | Bool_t ok = kTRUE; | |
743 | ||
744 | if(fMethodSecond) detVdrift = kVdriftLinear; | |
745 | ||
746 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(detVdrift); | |
747 | if(calDet) { | |
748 | Double_t mean = calDet->GetMean(); | |
749 | Double_t rms = calDet->GetRMS(); | |
750 | //printf("Vdrift::mean %f, rms %f\n",mean,rms); | |
751 | if(!((mean > 1.0) && (mean < 2.0) && (rms < 0.5))) ok = kFALSE; | |
752 | } | |
753 | else return kFALSE; | |
754 | ||
755 | if(!fMethodSecond) { | |
756 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kVdriftPHPad); | |
757 | if(calPad) { | |
758 | Double_t mean = calPad->GetMean(); | |
759 | Double_t rms = calPad->GetRMS(); | |
760 | //printf("Vdrift::meanpad %f, rmspad %f\n",mean,rms); | |
761 | if(!((mean > 0.9) && (mean < 1.1) && (rms < 0.6))) ok = kFALSE; | |
762 | } | |
763 | else return kFALSE; | |
764 | } | |
765 | ||
766 | return ok; | |
767 | ||
768 | } | |
769 | //__________________________________________________________________________________________________________________________ | |
770 | Bool_t AliTRDPreprocessorOffline::ValidateT0(){ | |
771 | // | |
772 | // Update OCDB entry | |
773 | // | |
774 | ||
775 | AliTRDCalDet *calDet = (AliTRDCalDet *) fCalibObjects->At(kT0PHDet); | |
776 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kT0PHPad); | |
777 | if(calDet && calPad) { | |
778 | Double_t meandet = calDet->GetMean(); | |
779 | Double_t rmsdet = calDet->GetRMS(); | |
780 | Double_t meanpad = calPad->GetMean(); | |
781 | //Double_t rmspad = calPad->GetRMS(); | |
782 | //printf("T0::minimum %f, rmsdet %f,meanpad %f, rmspad %f\n",meandet,rmsdet,meanpad,rmspad); | |
783 | if((meandet > -1.5) && (meandet < 5.0) && (rmsdet < 4.0) && (meanpad < 5.0) && (meanpad > -0.5)) return kTRUE; | |
784 | else return kFALSE; | |
785 | } | |
786 | else return kFALSE; | |
787 | ||
788 | } | |
789 | //__________________________________________________________________________________________________________________________ | |
790 | Bool_t AliTRDPreprocessorOffline::ValidatePRF() const{ | |
791 | // | |
792 | // Update OCDB entry | |
793 | // | |
794 | ||
795 | AliTRDCalPad *calPad = (AliTRDCalPad *) fCalibObjects->At(kPRF); | |
796 | if(calPad) { | |
797 | Double_t meanpad = calPad->GetMean(); | |
798 | Double_t rmspad = calPad->GetRMS(); | |
799 | //printf("PRF::meanpad %f, rmspad %f\n",meanpad,rmspad); | |
800 | if((meanpad < 1.0) && (rmspad < 0.8)) return kTRUE; | |
801 | else return kFALSE; | |
802 | } | |
803 | else return kFALSE; | |
804 | ||
805 | ||
b3fcfd96 | 806 | } |
4c865c34 | 807 | //_____________________________________________________________________________ |
808 | Int_t AliTRDPreprocessorOffline::GetVersion(TString name) const | |
809 | { | |
810 | // | |
811 | // Get version from the title | |
812 | // | |
813 | ||
814 | // Some patterns | |
815 | const Char_t *version = "Ver"; | |
816 | if(!strstr(name.Data(),version)) return -1; | |
817 | ||
818 | for(Int_t ver = 0; ver < 999999999; ver++) { | |
819 | ||
820 | TString vertry(version); | |
821 | vertry += ver; | |
822 | vertry += "Subver"; | |
823 | ||
824 | //printf("vertry %s and name %s\n",vertry.Data(),name.Data()); | |
825 | ||
826 | if(strstr(name.Data(),vertry.Data())) return ver; | |
827 | ||
828 | } | |
829 | ||
830 | return -1; | |
831 | ||
832 | } | |
833 | ||
834 | //_____________________________________________________________________________ | |
835 | Int_t AliTRDPreprocessorOffline::GetSubVersion(TString name) const | |
836 | { | |
837 | // | |
838 | // Get subversion from the title | |
839 | // | |
840 | ||
841 | // Some patterns | |
842 | const Char_t *subversion = "Subver"; | |
843 | if(!strstr(name.Data(),subversion)) return -1; | |
844 | ||
845 | for(Int_t ver = 0; ver < 999999999; ver++) { | |
846 | ||
847 | TString vertry(subversion); | |
848 | vertry += ver; | |
849 | vertry += "Nz"; | |
850 | ||
851 | //printf("vertry %s and name %s\n",vertry.Data(),name.Data()); | |
852 | ||
853 | if(strstr(name.Data(),vertry.Data())) return ver; | |
854 | ||
855 | } | |
856 | ||
857 | return -1; | |
858 | ||
859 | } | |
01239968 | 860 | |
81a5aeca | 861 | //_____________________________________________________________________________ |
862 | AliTRDCalChamberStatus *AliTRDPreprocessorOffline::ProduceChamberStatus() | |
863 | { | |
864 | // | |
865 | // Produce AliTRDCalChamberStatus out of calibration results | |
866 | // | |
867 | ||
868 | // set up AliTRDCalChamberStatus | |
869 | AliTRDCalChamberStatus *CalChamberStatus = new AliTRDCalChamberStatus(); | |
870 | ||
871 | // get calibration objects | |
872 | AliTRDCalDet *calDetGain = (AliTRDCalDet *) fCalibObjects->At(kGain); | |
873 | AliTRDCalDet *calDetVDrift = (AliTRDCalDet *) fCalibObjects->At(kVdriftLinear); | |
874 | ||
875 | // mask chambers with empty gain entries | |
876 | TH1I *projch = 0x0; | |
877 | Int_t counter = 0; | |
878 | for (Int_t idet = 0; idet < 540; idet++) { | |
879 | ||
880 | // ch2d | |
bed2a275 | 881 | if (projch) projch->Reset("CE"); |
81a5aeca | 882 | projch = (TH1I *) fCH2d->ProjectionX("projch",idet+1,idet+1,(Option_t *)"e"); |
883 | Int_t entries = projch->GetEntries(); | |
884 | ||
885 | // gain | |
886 | Double_t defaultgain = calDetGain->GetMean(); | |
887 | Double_t gain = calDetGain->GetValue(idet); | |
888 | ||
889 | // vdrift | |
890 | Double_t defaultvdrift = calDetVDrift->GetMean(); | |
891 | Double_t vdrift = calDetVDrift->GetValue(idet); | |
892 | ||
893 | ||
894 | if(entries<=0 || | |
895 | TMath::Abs(defaultgain-gain) < 0.5 || | |
896 | TMath::Abs(defaultvdrift-vdrift) < 0.1) { | |
897 | ||
898 | printf(" chamber det %03d masked \n",idet); | |
899 | CalChamberStatus->SetStatus(idet,2); | |
900 | counter++; | |
901 | } | |
902 | ||
903 | // installed supermodules+1 -> abort | |
904 | if(counter > (7+1)*30) { | |
905 | printf("ERROR: more than one SM to be masked!! \n Abort...\n"); | |
906 | return 0x0; | |
907 | } | |
908 | ||
909 | } | |
910 | return CalChamberStatus; | |
911 | } |