]>
Commit | Line | Data |
---|---|---|
a6edf90e | 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 | ||
702ab87e | 16 | /* $Id$ */ |
17 | ||
18 | /* History of cvs commits: | |
19 | * | |
20 | * $Log$ | |
45e334f8 | 21 | * Revision 1.10 2005/05/28 14:19:04 schutz |
22 | * Compilation warnings fixed by T.P. | |
23 | * | |
702ab87e | 24 | */ |
a6edf90e | 25 | |
26 | //_________________________________________________________________________ | |
27 | // Class to calculate calibration parameters from beam tests etc. | |
28 | // First pass - one should calcuate pedestals, in the second pass - gains. | |
29 | // | |
30 | // To calculate pedestals we scan pedestals events and fill histos for each | |
31 | // channel. Then in each histo we find maximum and fit it with Gaussian in the | |
32 | // visinity of the maximum. Extracted mean and width of distribution are put into | |
33 | // resulting histogram which cheks results for 'reasonability'. | |
34 | // | |
35 | // To evaluate gains: scans beam events and calculate gain in the cristall with | |
36 | // maximal energy deposition, assuming, that 90% of energy deposited in it. | |
37 | // For each channel separate histogramm is filled. When scan is finished, | |
38 | // these histograms are fitted with Gaussian and finds mean and width, which | |
39 | // are put in final histogram. Finaly gains are checked for deviation from mean. | |
40 | ||
41 | // Finally fills database. | |
42 | // | |
43 | // Use Case: | |
44 | // AliPHOSCalibrator * c = new AliPHOSCalibrator("path/galice.root") ; | |
45 | // c->AddRun("path2/galice.root") ; | |
46 | // c->ScanPedestals(); | |
47 | // c->CalculatePedestals(); | |
48 | // c->WritePedestals(); | |
49 | // c->ScanGains() ; | |
50 | // c->CalculateGains() ; | |
51 | // c->WriteGains() ; | |
52 | // | |
53 | //*-- Author : D.Peressounko (RRC KI) | |
54 | ////////////////////////////////////////////////////////////////////////////// | |
55 | ||
56 | // --- ROOT system --- | |
a6edf90e | 57 | #include "TF1.h" |
024a7e64 | 58 | #include "TFile.h" |
a6edf90e | 59 | #include "TObjString.h" |
024a7e64 | 60 | #include "TROOT.h" |
9b471956 | 61 | #include "TClonesArray.h" |
e957fea8 | 62 | |
a6edf90e | 63 | // --- Standard library --- |
64 | ||
65 | // --- AliRoot header files --- | |
6f06e050 | 66 | #include "AliLog.h" |
a6edf90e | 67 | #include "AliPHOSCalibrManager.h" |
68 | #include "AliPHOSCalibrationData.h" | |
024a7e64 | 69 | #include "AliPHOSCalibrator.h" |
70 | #include "AliPHOSConTableDB.h" | |
3255d660 | 71 | #include "AliRawReaderDate.h" |
45e334f8 | 72 | #include "AliPHOSRawStream2004.h" |
9b471956 | 73 | #include "AliPHOSDigit.h" |
a6edf90e | 74 | |
3255d660 | 75 | #ifdef ALI_DATE |
76 | #include "event.h" | |
77 | #else | |
78 | #define PHYSICS_EVENT 7 | |
79 | #endif | |
80 | ||
a6edf90e | 81 | ClassImp(AliPHOSCalibrator) |
82 | ||
83 | ||
84 | //____________________________________________________________________________ | |
85 | AliPHOSCalibrator::AliPHOSCalibrator():TTask("AliPHOSCalibrator","Default") | |
86 | { | |
87 | //Default constuctor for root. Normally should not be used | |
88 | fRunList=0 ; | |
9b471956 | 89 | fBeamEnergy = 0. ; |
a6edf90e | 90 | fNch = 0 ; |
91 | fPedHistos = 0 ; | |
92 | fGainHistos = 0 ; | |
93 | fhPedestals = 0 ; | |
94 | fhPedestalsWid = 0 ; | |
95 | fctdb = 0 ; | |
96 | fConTableDB = "Beamtest2002" ; | |
97 | fConTableDBFile = "ConTableDB.root" ; | |
98 | } | |
99 | //____________________________________________________________________________ | |
88cb7938 | 100 | AliPHOSCalibrator::AliPHOSCalibrator(const char* file, const char* title): |
a6edf90e | 101 | TTask("AliPHOSCalibrator",title) |
00953b03 | 102 | { |
103 | //Constructor which should normally be used. | |
a6edf90e | 104 | //file: path/galice.root - header file |
105 | //title: branch name of PHOS reconstruction (e.g. "Default") | |
88cb7938 | 106 | |
a6edf90e | 107 | |
108 | fRunList = new TList() ; | |
109 | fRunList->SetOwner() ; | |
110 | fRunList->Add(new TObjString(file)) ; | |
a6edf90e | 111 | fNch = 0 ; |
9b471956 | 112 | fBeamEnergy = 10. ; |
a6edf90e | 113 | |
114 | fNChan = 100 ; | |
115 | fGainMax = 0.1 ; | |
116 | fNGainBins= 100 ; | |
117 | fAcceptCorr = 10 ; //Maximal deviation from mean, considered as normal | |
118 | ||
119 | fGainAcceptCorr = 5 ; //Factor for gain deviation | |
120 | fPedHistos = 0 ; | |
121 | fGainHistos = 0 ; | |
122 | fhPedestals = 0 ; | |
123 | fhPedestalsWid = 0 ; | |
124 | fctdb = 0 ; | |
125 | fConTableDB = "Beamtest2002" ; | |
126 | fConTableDBFile = "ConTableDB.root" ; | |
127 | } | |
128 | ||
129 | //____________________________________________________________________________ | |
130 | AliPHOSCalibrator::~AliPHOSCalibrator() | |
131 | { | |
00953b03 | 132 | // dtor |
a6edf90e | 133 | if(fPedHistos) |
134 | delete fPedHistos ; | |
135 | if(fGainHistos) | |
136 | delete fGainHistos ; | |
137 | if(fhPedestals) | |
138 | delete fhPedestals ; | |
139 | if(fhPedestalsWid) | |
140 | delete fhPedestalsWid ; | |
141 | if(fctdb) | |
142 | delete fctdb ; | |
143 | if(fRunList) | |
144 | delete fRunList ; | |
145 | } | |
146 | //____________________________________________________________________________ | |
00953b03 | 147 | void AliPHOSCalibrator::AddRun(const char * filename) |
148 | { | |
a6edf90e | 149 | //Adds one more run to list of runs, which will be scanned in ScanXXX methods |
150 | ||
151 | TObjString * fn = new TObjString(filename) ; | |
152 | if(!fRunList){ | |
153 | fRunList=new TList() ; | |
154 | fRunList->SetOwner() ; | |
155 | fRunList->Add(fn) ; | |
156 | return ; | |
157 | } | |
158 | else{ | |
159 | TIter next(fRunList) ; | |
160 | TObjString * r ; | |
161 | while((r=(TObjString *)(next()))){ | |
162 | if(fn->String().CompareTo(r->String())==0){ | |
6f06e050 | 163 | AliError(Form("Run already in list: %s",filename)) ; |
a6edf90e | 164 | return ; |
165 | } | |
166 | } | |
167 | fRunList->Add(fn) ; | |
168 | } | |
169 | ||
170 | } | |
171 | //____________________________________________________________________________ | |
172 | void AliPHOSCalibrator::Exec(Option_t * option) | |
173 | { | |
00953b03 | 174 | // reads parameters and does the calibration |
a6edf90e | 175 | ScanPedestals(option); |
176 | CalculatePedestals(); | |
177 | WritePedestals(); | |
178 | ScanGains(option) ; | |
179 | CalculateGains() ; | |
180 | WriteGains() ; | |
181 | } | |
182 | //____________________________________________________________________________ | |
00953b03 | 183 | void AliPHOSCalibrator::Init(void) |
184 | { | |
185 | // intializes everything | |
a6edf90e | 186 | |
187 | //check if ConTableDB already read | |
188 | if(!fctdb){ | |
9b471956 | 189 | SetConTableDB(fConTableDBFile) ; |
a6edf90e | 190 | } |
191 | ||
192 | fNch = fctdb->GetNchanels() ; | |
193 | fhPedestals = new TH1F("hPedestals","Pedestals mean",fNch,0.,fNch) ; | |
194 | fhPedestalsWid= new TH1F("hPedestalsWid","Pedestals width",fNch,0.,fNch) ; | |
195 | fhGains = new TH1F("hGains","Gains ",fNch,0.,fNch) ; | |
196 | fhGainsWid = new TH1F("hGainsWid","Gains width",fNch,0.,fNch) ; | |
197 | } | |
198 | //____________________________________________________________________________ | |
00953b03 | 199 | void AliPHOSCalibrator::SetConTableDB(const char * file,const char * name) |
200 | { | |
a6edf90e | 201 | //Reads Connection Table database with name "name" from file "file" |
202 | ||
203 | if(file==0 || name == 0){ | |
6f06e050 | 204 | AliError(Form("Please, specify file with database and its title")) ; |
a6edf90e | 205 | return ; |
206 | } | |
207 | if(fctdb && strcmp(fctdb->GetTitle(),name)==0) //already read | |
208 | return ; | |
209 | ||
210 | //else read new one | |
211 | if(fctdb){ | |
212 | delete fctdb ; | |
213 | fctdb = 0; | |
214 | } | |
215 | ||
216 | TFile * v = gROOT->GetFile(fConTableDBFile) ; | |
217 | if(!v) | |
218 | v = TFile::Open(fConTableDBFile) ; | |
219 | if(!v){ | |
6f06e050 | 220 | AliError(Form("Can not open file with Connection Table DB: %s",fConTableDBFile.Data())) ; |
a6edf90e | 221 | return ; |
222 | } | |
9b471956 | 223 | fctdb = new AliPHOSConTableDB(*(dynamic_cast<AliPHOSConTableDB *>(v->Get("AliPHOSConTableDB")))) ; |
224 | v->Close() ; | |
a6edf90e | 225 | |
226 | } | |
227 | //____________________________________________________________________________ | |
00953b03 | 228 | void AliPHOSCalibrator::PlotPedestal(Int_t chanel) |
229 | { | |
a6edf90e | 230 | //Plot histogram for a given channel, filled in Scan method |
231 | if(fPedHistos && fPedHistos->GetEntriesFast()){ | |
232 | static_cast<TH1F*>(fPedHistos->At(chanel))->Draw() ; | |
233 | } | |
234 | else{ | |
6f06e050 | 235 | AliInfo(Form("Histograms not created yet! \n")) ; |
a6edf90e | 236 | } |
237 | } | |
238 | //____________________________________________________________________________ | |
00953b03 | 239 | void AliPHOSCalibrator::PlotPedestals(void) |
240 | { | |
241 | // draws pedestals distribution | |
a6edf90e | 242 | fhPedestals->Draw() ; |
243 | } | |
244 | //____________________________________________________________________________ | |
00953b03 | 245 | void AliPHOSCalibrator::PlotGain(Int_t chanel) |
246 | { | |
a6edf90e | 247 | //Plot histogram for a given channel, filled in Scan method |
248 | if(fGainHistos && fGainHistos->GetEntriesFast()){ | |
249 | static_cast<TH1F*>(fGainHistos->At(chanel))->Draw() ; | |
250 | } | |
251 | else{ | |
6f06e050 | 252 | AliInfo(Form("Histograms not created yet! \n")) ; |
a6edf90e | 253 | } |
254 | } | |
255 | //____________________________________________________________________________ | |
00953b03 | 256 | void AliPHOSCalibrator::PlotGains(void) |
257 | { | |
258 | // draws gains distribution | |
a6edf90e | 259 | fhGains->Draw() ; |
260 | } | |
261 | //____________________________________________________________________________ | |
00953b03 | 262 | void AliPHOSCalibrator::ScanPedestals(Option_t * option ) |
263 | { | |
a6edf90e | 264 | //scan all files in list fRunList and fill pedestal hisgrams |
265 | //option: "clear" - clear pedestal histograms filled up to now | |
266 | // "deb" - plot file name currently processed | |
267 | ||
268 | if(!fctdb) | |
269 | Init() ; | |
270 | ||
271 | if(fPedHistos && strstr(option,"clear")) | |
272 | fPedHistos->Delete() ; | |
273 | if(!fPedHistos) | |
274 | fPedHistos = new TObjArray(fNch) ; | |
275 | ||
276 | //Create histos for each channel, fills them and extracts mean values. | |
277 | //First - prepare histos | |
278 | Int_t ich ; | |
279 | for(ich=0;ich<fNch ;ich++){ | |
280 | TH1F * h = static_cast<TH1F *>(fPedHistos->At(ich)) ; | |
281 | if(!h ){ | |
282 | TString n("hPed"); | |
283 | n+=ich ; | |
284 | TString name("Pedestal for channel ") ; | |
285 | name += ich ; | |
286 | fPedHistos->AddAt(new TH1F(n,name,fNChan,0,fNChan),ich) ; | |
287 | } | |
288 | } | |
289 | ||
290 | TIter next(fRunList) ; | |
291 | TObjString * file ; | |
292 | while((file = static_cast<TObjString *>(next()))){ | |
293 | if(strstr(option,"deb")) | |
294 | printf("Processing file %s \n ",file->String().Data()) ; | |
6f06e050 | 295 | |
9b471956 | 296 | //Now open data file |
3255d660 | 297 | AliRawReaderDate *rawReader = new AliRawReaderDate(file->String().Data()) ; |
45e334f8 | 298 | AliPHOSRawStream2004 *rawStream = new AliPHOSRawStream2004(rawReader) ; |
9b471956 | 299 | rawStream->SetConTableDB(fctdb) ; |
300 | TClonesArray * digits = new TClonesArray("AliPHOSDigit",300) ; | |
301 | Int_t nevents=0 ; | |
302 | //Scan all event in file | |
303 | while(rawReader->NextEvent()){ | |
304 | //Is it PHYSICAL event | |
305 | if(rawReader->GetType() == PHYSICS_EVENT){ | |
306 | nevents++ ; | |
307 | if(rawStream->ReadDigits(digits)){ | |
308 | if(rawStream->IsPEDevent()){ | |
309 | for(Int_t idigit = 0; idigit<digits->GetEntriesFast() ; idigit++){ | |
310 | AliPHOSDigit * digit = static_cast<AliPHOSDigit *>(digits->At(idigit) ) ; | |
311 | ich = fctdb->AbsId2Raw(digit->GetId()); | |
312 | if(ich>=0){ | |
313 | Float_t amp = digit->GetAmp() ; | |
314 | TH1F * hh = dynamic_cast<TH1F*>(fPedHistos->At(ich)) ; | |
315 | hh->Fill(amp) ; | |
316 | } | |
317 | } | |
a6edf90e | 318 | } |
319 | } | |
320 | } | |
321 | } | |
9b471956 | 322 | if(strstr(option,"deb")) |
6f06e050 | 323 | AliInfo(Form(" found %d events \n ",nevents)) ; |
9b471956 | 324 | delete rawStream ; |
325 | delete rawReader ; | |
326 | delete digits ; | |
327 | } | |
a6edf90e | 328 | } |
329 | //____________________________________________________________________________ | |
00953b03 | 330 | void AliPHOSCalibrator::CalculatePedestals() |
331 | { | |
a6edf90e | 332 | //Fit histograms, filled in ScanPedestals method with Gaussian |
333 | //find mean and width, check deviation from mean for each channel. | |
334 | ||
335 | if(!fPedHistos || !fPedHistos->At(0)){ | |
6f06e050 | 336 | AliError(Form("You should run ScanPedestals first!")) ; |
a6edf90e | 337 | return ; |
338 | } | |
339 | ||
340 | //Now fit results with Gauss | |
341 | TF1 * gs = new TF1("gs","gaus",0.,10000.) ; | |
342 | Int_t ich ; | |
343 | for(ich=0;ich<fNch ;ich++){ | |
344 | TH1F * h = static_cast<TH1F *>(fPedHistos->At(ich)) ; | |
345 | Int_t max = h->GetMaximumBin() ; | |
346 | Axis_t xmin = max/2. ; | |
347 | Axis_t xmax = max*3/2 ; | |
348 | gs->SetRange(xmin,xmax) ; | |
349 | Double_t par[3] ; | |
350 | par[0] = h->GetBinContent(max) ; | |
351 | par[1] = max ; | |
352 | par[2] = max/3 ; | |
353 | gs->SetParameters(par[0],par[1],par[2]) ; | |
354 | h->Fit("gs","QR") ; | |
355 | gs->GetParameters(par) ; | |
356 | fhPedestals->SetBinContent(ich,par[1]) ; | |
357 | fhPedestals->SetBinError(ich,par[2]) ; | |
358 | fhPedestalsWid->Fill(ich,par[2]) ; | |
359 | } | |
360 | delete gs ; | |
361 | ||
362 | //now check reasonability of results | |
363 | TF1 * p0 = new TF1("p0","pol0",0.,fNch) ; | |
364 | fhPedestals->Fit("p0","Q") ; | |
365 | Double_t meanPed ; | |
366 | p0->GetParameters(&meanPed); | |
367 | for(ich=0;ich<fNch ;ich++){ | |
368 | Float_t ped = fhPedestals->GetBinContent(ich) ; | |
369 | if(ped < 0 || ped > meanPed+fAcceptCorr){ | |
370 | TString out("Pedestal of channel ") ; | |
371 | out+=ich ; | |
372 | out+=" is "; | |
373 | out+= ped ; | |
374 | out+= "it is too far from mean " ; | |
375 | out+= meanPed ; | |
6f06e050 | 376 | AliError(Form("PHOSCalibrator %s",out.Data())) ; |
a6edf90e | 377 | } |
378 | } | |
379 | delete p0 ; | |
380 | ||
381 | } | |
382 | //____________________________________________________________________________ | |
00953b03 | 383 | void AliPHOSCalibrator::ScanGains(Option_t * option) |
384 | { | |
a6edf90e | 385 | //Scan all runs, listed in fRunList and fill histograms for all channels |
386 | //options: "clear" - clean histograms, filled up to now | |
387 | // "deb" - print current file name | |
388 | // "narrow" - scan only narrow beam events | |
389 | ||
390 | if(!fctdb) | |
391 | Init() ; | |
392 | if(fGainHistos && strstr(option,"clear")) | |
393 | fGainHistos->Delete() ; | |
394 | if(!fGainHistos){ | |
395 | if(strstr(option,"deball")) | |
6f06e050 | 396 | AliInfo(Form("creating array for %d channels \n",fNch)) ; |
a6edf90e | 397 | fGainHistos = new TObjArray(fNch) ; |
398 | } | |
399 | ||
400 | //Create histos for each channel, fills them and extracts mean values. | |
401 | //First - prepare histos | |
402 | ||
403 | if(!fGainHistos->GetEntriesFast()){ | |
404 | Int_t ich ; | |
405 | for(ich=0;ich<fNch ;ich++){ | |
406 | TString n("hGain"); | |
407 | n+=ich ; | |
408 | TString name("Gains for channel ") ; | |
409 | name += ich ; | |
410 | fGainHistos->AddAt(new TH1F(n,name,fNGainBins,0,fGainMax),ich) ; | |
411 | // static_cast<TH1F*>(fGainHistos->At(ich))->Sumw2() ; | |
412 | } | |
413 | } | |
414 | ||
a6edf90e | 415 | TIter next(fRunList) ; |
416 | TObjString * file ; | |
417 | while((file = static_cast<TObjString *>(next()))){ | |
9b471956 | 418 | //Now open data file |
3255d660 | 419 | AliRawReaderDate *rawReader = new AliRawReaderDate(file->String().Data()) ; |
45e334f8 | 420 | AliPHOSRawStream2004 *rawStream = new AliPHOSRawStream2004(rawReader) ; |
9b471956 | 421 | rawStream->SetConTableDB(fctdb) ; |
422 | ||
423 | TClonesArray * digits = new TClonesArray("AliPHOSDigit",300) ; | |
424 | Int_t nevents=0 ; | |
425 | //Scan all event in file | |
426 | while(rawReader->NextEvent()){ | |
427 | //Is it PHYSICAL event | |
428 | if(rawReader->GetType() == PHYSICS_EVENT){ | |
429 | if(rawStream->ReadDigits(digits)){ | |
430 | //Test trigger | |
431 | if(rawStream->IsNELevent() || rawStream->IsWELevent()){ | |
432 | nevents ++ ; | |
433 | AliPHOSDigit * digit ; | |
434 | Int_t max = 0 ; | |
435 | Int_t imax = 0; | |
436 | for(Int_t idigit = 0; idigit<digits->GetEntriesFast() ; idigit++){ | |
437 | digit = static_cast<AliPHOSDigit *>(digits->At(idigit) ) ; | |
438 | if(digit->GetAmp() > max){ | |
439 | imax = idigit ; | |
440 | max = digit->GetAmp() ; | |
441 | } | |
442 | } | |
443 | digit = static_cast<AliPHOSDigit *>(digits->At(imax) ) ; | |
444 | Int_t ich = fctdb->AbsId2Raw(digit->GetId()); | |
445 | if(ich>=0){ | |
446 | Float_t pedestal = fhPedestals->GetBinContent(ich) ; | |
447 | const Float_t kshowerInCrystall = 0.9 ; | |
448 | Float_t gain = fBeamEnergy*kshowerInCrystall/ | |
449 | (digit->GetAmp() - pedestal) ; | |
450 | static_cast<TH1F*>(fGainHistos->At(ich))->Fill(gain) ; | |
451 | } | |
a6edf90e | 452 | } |
453 | } | |
a6edf90e | 454 | } |
455 | } | |
9b471956 | 456 | delete rawReader ; |
457 | delete rawStream ; | |
458 | delete digits ; | |
6f06e050 | 459 | if(strstr(option,"deb")) |
460 | AliInfo(Form(" found %d events \n",nevents)) ; | |
a6edf90e | 461 | } |
462 | } | |
463 | //____________________________________________________________________________ | |
00953b03 | 464 | void AliPHOSCalibrator::CalculateGains(void) |
465 | { | |
466 | //calculates gain | |
a6edf90e | 467 | |
468 | if(!fGainHistos || !fGainHistos->GetEntriesFast()){ | |
6f06e050 | 469 | AliError(Form("You should run ScanGains first!")) ; |
a6edf90e | 470 | return ; |
471 | } | |
472 | ||
473 | //Fit results with Landau | |
474 | TF1 * gs = new TF1("gs","landau",0.,10000.) ; | |
475 | Int_t ich ; | |
476 | for(ich=0;ich<fNch ;ich++){ | |
477 | TH1F * h = static_cast<TH1F *>(fGainHistos->At(ich)) ; | |
478 | Int_t bmax = h->GetMaximumBin() ; | |
479 | Axis_t center = h->GetBinCenter(bmax) ; | |
480 | Axis_t xmin = center - 0.01 ; | |
481 | Axis_t xmax = center + 0.02 ; | |
482 | gs->SetRange(xmin,xmax) ; | |
483 | Double_t par[3] ; | |
484 | par[0] = h->GetBinContent(bmax) ; | |
485 | par[1] = center ; | |
486 | par[2] = 0.001 ; | |
487 | gs->SetParameters(par[0],par[1],par[2]) ; | |
488 | h->Fit("gs","QR") ; | |
489 | gs->GetParameters(par) ; | |
490 | fhGains->SetBinContent(ich,par[1]) ; | |
491 | fhGains->SetBinError(ich,par[2]) ; | |
492 | fhGainsWid->Fill(ich,par[2]) ; | |
493 | } | |
494 | delete gs ; | |
495 | ||
496 | //now check reasonability of results | |
497 | TF1 * p0 = new TF1("p0","pol0",0.,fNch) ; | |
498 | fhGains->Fit("p0","Q") ; | |
499 | Double_t meanGain ; | |
500 | p0->GetParameters(&meanGain); | |
501 | for(ich=0;ich<fNch ;ich++){ | |
502 | Float_t gain = fhGains->GetBinContent(ich) ; | |
503 | if(gain < meanGain/fGainAcceptCorr || gain > meanGain*fGainAcceptCorr){ | |
504 | TString out("Gain of channel ") ; | |
505 | out+=ich ; | |
506 | out+=" is "; | |
507 | out+= gain ; | |
508 | out+= "it is too far from mean " ; | |
509 | out+= meanGain ; | |
6f06e050 | 510 | AliError(Form("PHOSCalibrator %s",out.Data())) ; |
a6edf90e | 511 | } |
512 | } | |
513 | delete p0 ; | |
514 | ||
515 | } | |
9b471956 | 516 | //____________________________________________________________________________ |
517 | void AliPHOSCalibrator::ReadFromASCII(const char * filename){ | |
518 | // We read pedestals and gains from *.dat file with following format: | |
519 | // 0 0 0 0 37.09 1972. // next nmodrows*nmodcols*ncryrows*ncrycols lines | |
520 | // 0 0 0 1 28.53 2072. // contains <RR CC r c ped peak> | |
521 | // 0 0 0 2 30.93 1938. // | |
522 | // where module is an array of 8*8 crystals and RR and CC are module raw and column position | |
523 | FILE * file = fopen(filename, "r"); | |
524 | if (!file) { | |
525 | Error("ReadFromASCII", "could not open file %s", filename); | |
526 | return; | |
527 | } | |
528 | if(!fctdb || !fhPedestals || !fhGains){ | |
529 | Init() ; | |
530 | } | |
531 | else{ | |
532 | //Clean Hitograms | |
533 | Reset() ; | |
534 | } | |
a6edf90e | 535 | |
9b471956 | 536 | Int_t modRaw,modCol,raw,col; |
537 | Float_t ped,pik; | |
538 | Int_t nread = 0 ; | |
539 | while(fscanf(file,"%d %d %d %d %f %f",&modRaw,&modCol,&raw,&col,&ped,&pik)==6){ | |
540 | //Calculate plain crystal position: | |
541 | Int_t rawPosition = (modRaw*8+raw)*fctdb->GetNColumns()+modCol*8+col ; | |
542 | fhPedestals->SetBinContent(rawPosition,ped) ; | |
543 | if(pik!=0.) | |
544 | fhGains->SetBinContent(rawPosition,1./pik); | |
545 | else | |
546 | fhGains->SetBinContent(rawPosition,0.); | |
547 | nread++ ; | |
548 | } | |
549 | if(nread != fctdb->GetNColumns()*fctdb->GetNRaws()){ | |
550 | Error("ReadFromASCII","Read %d parameters instead of %d\n",nread,fctdb->GetNColumns()*fctdb->GetNRaws()) ; | |
551 | } | |
552 | fclose(file) ; | |
553 | } | |
a6edf90e | 554 | //_____________________________________________________________________________ |
9b471956 | 555 | void AliPHOSCalibrator::WritePedestals(const char * version) |
00953b03 | 556 | { |
a6edf90e | 557 | //Write calculated data to file using AliPHOSCalibrManager |
558 | //version and validitirange (begin-end) will be used to identify data | |
559 | ||
560 | if(!fctdb){ | |
6f06e050 | 561 | AliError(Form("\n Please, supply Connection Table DB (use SetConTableDB()) \n" )) ; |
a6edf90e | 562 | return ; |
563 | } | |
564 | //fill data | |
565 | AliPHOSCalibrationData ped("Pedestals",version); | |
566 | for(Int_t i=0; i<fNch;i++){ | |
567 | Int_t absid=fctdb->Raw2AbsId(i) ; | |
568 | ped.SetData(absid,fhPedestals->GetBinContent(i)) ; | |
569 | ped.SetDataCheck(absid,fhPedestalsWid->GetBinContent(i)) ; | |
570 | } | |
571 | ||
9b471956 | 572 | // //evaluate validity range |
573 | // if(begin==0){ | |
574 | // TIter next(fRunList) ; | |
575 | // Int_t ibegin=99999; | |
576 | // Int_t iend=0 ; | |
577 | // TObjString * file ; | |
578 | // while((file=((TObjString*)next()))){ | |
579 | // TString s = file->GetString() ; | |
580 | // TString ss = s(s.Last('_'),s.Last('.')); | |
581 | // Int_t tmp ; | |
582 | // if(sscanf(ss.Data(),"%d",&tmp)){ | |
583 | // if(ibegin<tmp) | |
584 | // ibegin=tmp ; | |
585 | // if(iend>tmp) | |
586 | // iend=tmp ; | |
587 | // } | |
588 | // } | |
589 | // ped.SetValidityRange(ibegin,iend) ; | |
590 | // } | |
591 | // else | |
592 | // ped.SetValidityRange(begin,end) ; | |
a6edf90e | 593 | |
594 | //check, may be Manager instance already configured? | |
595 | AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ; | |
596 | if(!cmngr){ | |
6f06e050 | 597 | AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ; |
a6edf90e | 598 | cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ; |
599 | } | |
9b471956 | 600 | cmngr->WriteData(ped) ; |
a6edf90e | 601 | } |
602 | //_____________________________________________________________________________ | |
9b471956 | 603 | void AliPHOSCalibrator::ReadPedestals(const char * version) |
00953b03 | 604 | { |
605 | //Read data from file using AliPHOSCalibrManager | |
a6edf90e | 606 | //version and range will be used to choose proper data |
607 | ||
608 | AliPHOSCalibrationData ped("Pedestals",version); | |
609 | AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ; | |
610 | if(!cmngr){ | |
6f06e050 | 611 | AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ; |
a6edf90e | 612 | cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ; |
613 | } | |
9b471956 | 614 | cmngr->GetParameters(ped) ; |
a6edf90e | 615 | Int_t npeds=ped.NChannels() ; |
616 | fNch = fctdb->GetNchanels() ; | |
617 | if(fhPedestals) | |
618 | delete fhPedestals ; | |
619 | fhPedestals = new TH1F("hPedestals","Pedestals mean",fNch,0.,fNch) ; | |
620 | for(Int_t i=0;i<npeds;i++){ | |
621 | Int_t raw =fctdb->AbsId2Raw(i) ; | |
622 | if(raw){ | |
623 | fhPedestals->SetBinContent(raw-1,ped.Data(i)) ; | |
624 | fhPedestals->SetBinError(raw-1,ped.DataCheck(i)) ; | |
625 | } | |
626 | } | |
627 | } | |
628 | //_____________________________________________________________________________ | |
9b471956 | 629 | void AliPHOSCalibrator::ReadGains(const char * version) |
00953b03 | 630 | { |
631 | //Read data from file using AliPHOSCalibrManager | |
a6edf90e | 632 | //version and range will be used to choose proper data |
633 | ||
634 | AliPHOSCalibrationData gains("Gains",version); | |
635 | AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ; | |
636 | if(!cmngr){ | |
6f06e050 | 637 | AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ; |
a6edf90e | 638 | cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ; |
639 | } | |
9b471956 | 640 | cmngr->GetParameters(gains) ; |
a6edf90e | 641 | Int_t npeds=gains.NChannels() ; |
642 | fNch = fctdb->GetNchanels() ; | |
643 | if(fhGains) | |
644 | delete fhGains ; | |
645 | fhGains = new TH1F("hGainss","Gains mean",fNch,0.,fNch) ; | |
646 | for(Int_t i=0;i<npeds;i++){ | |
647 | Int_t raw =fctdb->AbsId2Raw(i) ; | |
648 | if(raw){ | |
649 | fhGains->SetBinContent(raw-1,gains.Data(i)) ; | |
650 | fhGains->SetBinError(raw-1,gains.DataCheck(i)) ; | |
651 | } | |
652 | } | |
653 | } | |
654 | //_____________________________________________________________________________ | |
9b471956 | 655 | void AliPHOSCalibrator::WriteGains(const char * version) |
00953b03 | 656 | { |
657 | //Write gains through AliPHOSCalibrManager | |
a6edf90e | 658 | //version and validity range(begin-end) are used to identify data |
659 | ||
660 | if(!fctdb){ | |
6f06e050 | 661 | AliError(Form("\n Please, supply Connection Table DB (use SetConTableDB()) \n" )) ; |
a6edf90e | 662 | return ; |
663 | } | |
664 | ||
665 | AliPHOSCalibrationData gains("Gains",version); | |
666 | for(Int_t i=0; i<fNch;i++){ | |
667 | Int_t absid=fctdb->Raw2AbsId(i) ; | |
668 | gains.SetData(absid,fhGains->GetBinContent(i)) ; | |
669 | gains.SetDataCheck(absid,fhGainsWid->GetBinContent(i)) ; | |
670 | } | |
9b471956 | 671 | // if(begin==0){ |
672 | // TIter next(fRunList) ; | |
673 | // Int_t ibegin=99999; | |
674 | // Int_t iend=0 ; | |
675 | // TObjString * file ; | |
676 | // while((file=((TObjString*)next()))){ | |
677 | // TString s = file->GetString() ; | |
678 | // TSubString ss = s(s.Last('_'),s.Last('.')); | |
679 | // Int_t tmp ; | |
680 | // if(sscanf(ss.Data(),"%d",&tmp)){ | |
681 | // if(ibegin<tmp) | |
682 | // ibegin=tmp ; | |
683 | // if(iend>tmp) | |
684 | // iend=tmp ; | |
685 | // } | |
686 | // } | |
687 | // gains.SetValidityRange(ibegin,iend) ; | |
688 | // } | |
689 | // else | |
690 | // gains.SetValidityRange(begin,end) ; | |
a6edf90e | 691 | AliPHOSCalibrManager * cmngr = AliPHOSCalibrManager::GetInstance() ; |
692 | if(!cmngr){ | |
6f06e050 | 693 | AliWarning(Form("Using database file 'PHOSBTCalibration.root'")) ; |
a6edf90e | 694 | cmngr = AliPHOSCalibrManager::GetInstance("PHOSBTCalibration.root") ; |
695 | } | |
9b471956 | 696 | cmngr->WriteData(gains) ; |
a6edf90e | 697 | } |
698 | //_____________________________________________________________________________ | |
702ab87e | 699 | void AliPHOSCalibrator::Print(const Option_t *)const |
00953b03 | 700 | { |
701 | // prints everything | |
6f06e050 | 702 | AliInfo(Form("--------------PHOS Calibrator-----------------\n")) ; |
a6edf90e | 703 | printf("Files to handle:\n") ; |
704 | TIter next(fRunList) ; | |
705 | TObjString * r ; | |
706 | while((r=(TObjString *)(next()))) | |
707 | printf(" %s\n",r->GetName()) ; | |
708 | ||
709 | printf("Name of ConTableDB:.....................%s\n",fConTableDB.Data()) ; | |
710 | printf("File of ConTableDB:.....................%s\n",fConTableDBFile.Data() ) ; | |
711 | printf("Maximal deviation from mean Gain (factor):.%f\n",fGainAcceptCorr) ; | |
712 | printf("Maximal deviation of Pedestal from mean:...%f\n",fAcceptCorr) ; | |
713 | printf("Range used in Gain histos:..............%f\n",fGainMax) ; | |
714 | printf("Number of bins in Gain histos:..........%d\n",fNGainBins) ; | |
715 | printf("Number of channels to calibrate:........%d\n",fNch) ; | |
716 | printf("Number of bins in pedestal histos:......%d\n",fNChan) ; | |
a6edf90e | 717 | printf("--------------------------------------------------\n") ; |
718 | } |