]> git.uio.no Git - u/mrichter/AliRoot.git/blame_incremental - ITS/AliITSOnlineSPDscanAnalyzer.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Fixes for bug #62149 AliITSTrackleterSPDEff returns an error in case of 'empty' events
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDscanAnalyzer.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 2007-2009, 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// Author: Henrik Tydesjo //
20// This class is used in the detector algorithm framework //
21// to process the data stored in special container files //
22// (see AliITSOnlineSPDscan). For instance, minimum //
23// threshold values can be extracted. //
24////////////////////////////////////////////////////////////
25
26#include "AliITSOnlineSPDscanAnalyzer.h"
27#include "AliITSOnlineSPDscan.h"
28#include "AliITSOnlineSPDscanSingle.h"
29#include "AliITSOnlineSPDscanMultiple.h"
30#include "AliITSOnlineSPDscanMeanTh.h"
31#include "AliITSOnlineCalibrationSPDhandler.h"
32#include "AliITSRawStreamSPD.h"
33#include <TStyle.h>
34#include <TMath.h>
35#include <TF1.h>
36#include <TGraph.h>
37#include <TH2F.h>
38#include <TError.h>
39#include <iostream>
40#include <fstream>
41
42Double_t itsSpdErrorf(Double_t *x, Double_t *par){
43 if (par[2]<0) par[2]=0;
44 Double_t val = par[2]+(0.12*256*32-par[2])*(0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.)));
45 return val;
46}
47//Double_t itsSpdErrorfOrig(Double_t *x, Double_t *par){
48// return 0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.));
49//}
50
51//_________________________________________________________________________
52AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName, AliITSOnlineCalibrationSPDhandler *handler, Bool_t readFromGridFile) :
53 fType(99),fDacId(99),fFileName(fileName),fScanObj(NULL),fHandler(handler),fTriggers(NULL),fTPeff(0),fTPeffHS(NULL),fDeadPixel(0),fDeadPixelHS(NULL),fNoisyPixel(0),fNoisyPixelHS(NULL),
54 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
55 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
56{
57 // constructor
58 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
59 for (UInt_t hs=0; hs<6; hs++) {
60 fMeanMultiplicity[hs][chipNr]=NULL;
61 fHitEventEfficiency[hs][chipNr]=NULL;
62 }
63 }
64 for (UInt_t hs=0; hs<6; hs++) {
65 fTPeffChip[hs]=NULL;
66 fDeadPixelChip[hs]=NULL;
67 fNoisyPixelChip[hs]=NULL;
68 }
69
70 for (UInt_t mod=0; mod<240; mod++) {
71 fbModuleScanned[mod]=kFALSE;
72 }
73
74 Init(readFromGridFile);
75}
76//_________________________________________________________________________
77AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
78 fType(99),fDacId(99),fFileName("."),fScanObj(NULL),fHandler(NULL),fTriggers(NULL),fTPeff(0),fTPeffHS(NULL),fDeadPixel(0),fDeadPixelHS(NULL),fNoisyPixel(0),fNoisyPixelHS(NULL),
79 fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
80 fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(5),fMaxBaseLineLevel(10)
81{
82 // copy constructor, only copies the filename and params (not the processed data)
83 fFileName=handle.fFileName;
84 fOverWrite=handle.fOverWrite;
85 fNoiseThreshold=handle.fNoiseThreshold;
86 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
87 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
88 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
89 fStepDownDacSafe=handle.fStepDownDacSafe;
90 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
91
92 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
93 for (UInt_t hs=0; hs<6; hs++) {
94 fMeanMultiplicity[hs][chipNr]=NULL;
95 fHitEventEfficiency[hs][chipNr]=NULL;
96 }
97 }
98 for (UInt_t hs=0; hs<6; hs++) {
99 fTPeffChip[hs]=NULL;
100 fDeadPixelChip[hs]=NULL;
101 fNoisyPixelChip[hs]=NULL;
102 }
103
104 for (UInt_t mod=0; mod<240; mod++) {
105 fbModuleScanned[mod]=kFALSE;
106 }
107
108 Init();
109}
110//_________________________________________________________________________
111AliITSOnlineSPDscanAnalyzer::~AliITSOnlineSPDscanAnalyzer() {
112 // destructor
113 for (UInt_t hs=0; hs<6; hs++) {
114 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
115 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
116 delete fMeanMultiplicity[hs][chipNr];
117 fMeanMultiplicity[hs][chipNr]=NULL;
118 }
119 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
120 delete fHitEventEfficiency[hs][chipNr];
121 fHitEventEfficiency[hs][chipNr]=NULL;
122 }
123 }
124 }
125
126 if (fTriggers!=NULL) {
127 delete fTriggers;
128 fTriggers=NULL;
129 }
130
131 DeleteUniformityHistograms();
132
133 if (fScanObj!=NULL) {
134 delete fScanObj;
135 fScanObj=NULL;
136 }
137}
138//_________________________________________________________________________
139AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITSOnlineSPDscanAnalyzer& handle) {
140 // assignment operator, only copies the filename and params (not the processed data)
141 if (this!=&handle) {
142 for (UInt_t hs=0; hs<6; hs++) {
143 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
144 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
145 delete fMeanMultiplicity[hs][chipNr];
146 }
147 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
148 delete fHitEventEfficiency[hs][chipNr];
149 }
150 }
151 }
152 if (fTriggers!=NULL) {
153 delete fTriggers;
154 fTriggers=NULL;
155 }
156
157 DeleteUniformityHistograms();
158
159 if (fScanObj!=NULL) {
160 delete fScanObj;
161 fScanObj=NULL;
162 }
163
164 fFileName=handle.fFileName;
165 fOverWrite=handle.fOverWrite;
166 fNoiseThreshold=handle.fNoiseThreshold;
167 fNoiseMinimumEvents=handle.fNoiseMinimumEvents;
168 fMinNrStepsBeforeIncrease=handle.fMinNrStepsBeforeIncrease;
169 fMinIncreaseFromBaseLine=handle.fMinIncreaseFromBaseLine;
170 fStepDownDacSafe=handle.fStepDownDacSafe;
171 fMaxBaseLineLevel=handle.fMaxBaseLineLevel;
172
173 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
174 for (UInt_t hs=0; hs<6; hs++) {
175 fMeanMultiplicity[hs][chipNr]=NULL;
176 fHitEventEfficiency[hs][chipNr]=NULL;
177 }
178 }
179 for (UInt_t mod=0; mod<240; mod++) {
180 fbModuleScanned[mod]=kFALSE;
181 }
182
183 fHandler=NULL;
184
185 fType=99;
186 fDacId=99;
187
188 Init();
189 }
190 return *this;
191}
192//_________________________________________________________________________
193void AliITSOnlineSPDscanAnalyzer::Init(Bool_t readFromGridFile) {
194 // first checks type of container and then initializes container obj
195 if (!readFromGridFile) {
196 FILE* fp0 = fopen(fFileName.Data(), "r");
197 if (fp0 == NULL) {
198 return;
199 }
200 else {
201 fclose(fp0);
202 }
203 }
204
205 fScanObj = new AliITSOnlineSPDscan(fFileName.Data(),readFromGridFile);
206 fType = fScanObj->GetType();
207 delete fScanObj;
208
209 // init container
210 switch(fType) {
211 case kUNIMA:
212 case kNOISE:
213 fScanObj = new AliITSOnlineSPDscanSingle(fFileName.Data(),readFromGridFile);
214 break;
215 case kMINTH:
216 case kDAC:
217 case kDELAY:
218 fScanObj = new AliITSOnlineSPDscanMultiple(fFileName.Data(),readFromGridFile);
219 fDacId = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacId();
220 break;
221 case kMEANTH:
222 fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName.Data(),readFromGridFile);
223 fDacId = ((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetDacId();
224 break;
225 default:
226 Error("AliITSOnlineSPDscanAnalyzer::Init","Type %d not defined!",fType);
227 fScanObj=NULL;
228 return;
229 break;
230 }
231
232}
233//_________________________________________________________________________
234void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
235 // set a parameter
236 TString name = pname;
237 TString val = pval;
238 if (name.CompareTo("fOverWrite")==0) {
239 if (val.CompareTo("YES")==0 || val.CompareTo("1")==0) {
240 fOverWrite = kTRUE;
241 }
242 else fOverWrite = kFALSE;
243 }
244 else if (name.CompareTo("fNoiseThreshold")==0) {
245 fNoiseThreshold = val.Atof();
246 }
247 else if (name.CompareTo("fNoiseMinimumEvents")==0) {
248 fNoiseMinimumEvents = val.Atoi();
249 }
250 else if (name.CompareTo("fMinNrStepsBeforeIncrease")==0) {
251 fMinNrStepsBeforeIncrease = val.Atoi();
252 }
253 else if (name.CompareTo("fMinIncreaseFromBaseLine")==0) {
254 fMinIncreaseFromBaseLine = val.Atof();
255 }
256 else if (name.CompareTo("fStepDownDacSafe")==0) {
257 fStepDownDacSafe = val.Atoi();
258 }
259 else if (name.CompareTo("fMaxBaseLineLevel")==0) {
260 fMaxBaseLineLevel = val.Atof();
261 }
262 else {
263 Error("AliITSOnlineSPDscanAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
264 }
265}
266//_________________________________________________________________________
267void AliITSOnlineSPDscanAnalyzer::ReadParamsFromLocation(const Char_t *dirName) {
268 // opens file (default name) in dir dirName and reads parameters from it
269 TString paramsFileName = Form("%s/standal_params.txt",dirName);
270 ifstream paramsFile;
271 paramsFile.open(paramsFileName, ifstream::in);
272 if (paramsFile.fail()) {
273 printf("No config file (%s) present. Using default tuning parameters.\n",paramsFileName.Data());
274 }
275 else {
276 while(1) {
277 Char_t paramN[50];
278 Char_t paramV[50];
279 paramsFile >> paramN;
280 if (paramsFile.eof()) break;
281 paramsFile >> paramV;
282 SetParam(paramN,paramV);
283 if (paramsFile.eof()) break;
284 }
285 paramsFile.close();
286 }
287}
288//_________________________________________________________________________
289Bool_t AliITSOnlineSPDscanAnalyzer::IsChipPresent(UInt_t hs, UInt_t chipNr) {
290 // is the chip present?
291 if (fScanObj==NULL) {
292 Warning("AliITSOnlineSPDscanAnalyzer::IsChipPresent","No data!");
293 return kFALSE;
294 }
295 return fScanObj->GetChipPresent(hs,chipNr);
296}
297//_________________________________________________________________________
298Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(/*Char_t *oldcalibDir*/) {
299 // process dead pixel data, for uniformity scan,
300 // NB: This will not be the general way of finding dead pixels.
301 if (fScanObj==NULL) {
302 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","No data!");
303 return kFALSE;
304 }
305 // should be type kUNIMA
306 if (fType!=kUNIMA) {
307 Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
308 return kFALSE;
309 }
310 // handler should be initialized
311 if (fHandler==NULL) {
312 Error("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Calibration handler is not initialized!");
313 return kFALSE;
314 }
315
316 UInt_t routerNr = fScanObj->GetRouterNr();
317 UInt_t rowStart = fScanObj->GetRowStart();
318 UInt_t rowEnd = fScanObj->GetRowEnd();
319 for (UInt_t hs=0; hs<6; hs++) {
320 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
321 if (fScanObj->GetChipPresent(hs,chipNr) && fScanObj->GetAverageMultiplicity(0,hs,chipNr)>0) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
322 if (fOverWrite) {fHandler->ResetDeadForChip(routerNr,hs,chipNr);}
323 for (UInt_t col=0; col<32; col++) {
324 for (UInt_t row=rowStart; row<=rowEnd; row++) {
325 if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
326 if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
327 fHandler->SetDeadPixel(routerNr,hs,chipNr,col,row);
328 }
329 }
330 }
331 }
332 }
333 }
334 }
335 return kTRUE;
336}
337//_________________________________________________________________________
338Bool_t AliITSOnlineSPDscanAnalyzer::ProcessUniformity() {
339 // process uniformity scan data (thanks to Roberta Ferretti for providing this method)
340 if (fScanObj==NULL) {
341 Warning("AliITSOnlineSPDscanAnalyzer::ProcessUniformity","No data!");
342 return kFALSE;
343 }
344 // should be type kUNIMA
345 if (fType!=kUNIMA) {
346 Warning("AliITSOnlineSPDscanAnalyzer::ProcessUniformity","Only for scan type %d.",kUNIMA);
347 return kFALSE;
348 }
349
350 CreateUniformityHistograms(); // create all histograms that will be filled here
351
352 // UInt_t routerNr = fScanObj->GetRouterNr();
353 UInt_t rowStart = fScanObj->GetRowStart();
354 UInt_t rowEnd = fScanObj->GetRowEnd();
355 UInt_t NrTriggers = fScanObj->GetTriggers(0)/(rowEnd-rowStart+1);
356
357 Float_t pixel100=0;
358 Float_t zeri=0;
359 Float_t pixelN=0;
360 UInt_t numChipsActive=0;
361
362 for (UInt_t hs=0; hs<6; hs++) {
363 Float_t pixel100hs=0;
364 Float_t zerihs=0;
365 Float_t pixelNhs=0;
366 UInt_t numChipsActiveHS=0;
367
368 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
369 Float_t pixel100chip=0;
370 Float_t zerichip=0;
371 Float_t pixelNchip=0;
372
373 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
374 numChipsActive++;
375 numChipsActiveHS++;
376
377 for (UInt_t col=0; col<32; col++) {
378 for (UInt_t row=rowStart; row<=rowEnd; row++) {
379 if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
380
381 if (fScanObj->GetHits(0,hs,chipNr,col,row)==NrTriggers) {
382 pixel100++;
383 pixel100hs++;
384 pixel100chip++;
385 }
386 if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
387 zeri++;
388 zerihs++;
389 zerichip++;
390 }
391 if (fScanObj->GetHits(0,hs,chipNr,col,row)>NrTriggers) {
392 pixelN++;
393 pixelNhs++;
394 pixelNchip++;
395 }
396 }
397 }
398 }
399
400 Float_t TPeffChip=(pixel100chip/(28*(rowEnd-rowStart+1)))*100;
401 fTPeffChip[hs]->Fill(chipNr,TPeffChip);
402
403 Float_t DeadPixelChip=(zerichip/(28*(rowEnd-rowStart+1)))*100;
404 fDeadPixelChip[hs]->Fill(chipNr,DeadPixelChip);
405
406 Float_t NoisyPixelChip=(pixelNchip/(28*(rowEnd-rowStart+1)))*100;
407 fNoisyPixelChip[hs]->Fill(chipNr,NoisyPixelChip);
408 }
409 }
410
411 Float_t TPeffHS=(pixel100hs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
412 fTPeffHS->Fill(hs,TPeffHS);
413
414 Float_t DeadPixelHS=(zerihs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
415 fDeadPixelHS->Fill(hs,DeadPixelHS);
416
417 Float_t NoisyPixelHS=(pixelNhs/(28*numChipsActiveHS*(rowEnd-rowStart+1)))*100;
418 fNoisyPixelHS->Fill(hs,NoisyPixelHS);
419 }
420
421 fTPeff=(pixel100/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
422 fDeadPixel=(zeri/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
423 fNoisyPixel=(pixelN/(28*numChipsActive*(rowEnd-rowStart+1)))*100;
424
425 return kTRUE;
426}
427//_________________________________________________________________________
428void AliITSOnlineSPDscanAnalyzer::CreateUniformityHistograms() {
429 // create uniformity histograms to be filled by "ProcessUniformity" method
430 DeleteUniformityHistograms(); // make sure no old histograms are lying around...
431 UInt_t eq = GetRouterNr();
432 TString label;
433
434 label = Form("Ratio of 'Good' Pixels Per HS (eq %d)",eq);
435 fTPeffHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
436 fTPeffHS->SetXTitle("hs");
437 fTPeffHS->SetYTitle("ratio [%]");
438 fTPeffHS->SetFillColor(kBlue);
439 fTPeffHS->SetStats(0);
440
441 label = Form("Ratio of 'Dead' Pixels Per HS (eq %d)",eq);
442 fDeadPixelHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
443 fDeadPixelHS->SetXTitle("hs");
444 fDeadPixelHS->SetYTitle("ratio [%]");
445 fDeadPixelHS->SetFillColor(kBlue);
446 fDeadPixelHS->SetStats(0);
447
448 label = Form("Ratio of 'Noisy' Pixels Per HS (eq %d)",eq);
449 fNoisyPixelHS = new TH1F(label.Data(),label.Data(),6,-0.5,5.5);
450 fNoisyPixelHS->SetXTitle("hs");
451 fNoisyPixelHS->SetYTitle("ratio [%]");
452 fNoisyPixelHS->SetFillColor(kBlue);
453 fNoisyPixelHS->SetStats(0);
454
455 for (UInt_t hs=0; hs<6; hs++) {
456 label = Form("Ratio of 'Good' Pixels Per Chip (eq %d, hs %d)",eq,hs);
457 fTPeffChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
458 fTPeffChip[hs]->SetXTitle("chip");
459 fTPeffChip[hs]->SetYTitle("ratio [%]");
460 fTPeffChip[hs]->SetFillColor(kBlue);
461 fTPeffChip[hs]->SetStats(0);
462
463 label = Form("Ratio of 'Dead' Pixels Per Chip (eq %d, hs %d)",eq,hs);
464 fDeadPixelChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
465 fDeadPixelChip[hs]->SetXTitle("chip");
466 fDeadPixelChip[hs]->SetYTitle("ratio [%]");
467 fDeadPixelChip[hs]->SetFillColor(kBlue);
468 fDeadPixelChip[hs]->SetStats(0);
469
470 label = Form("Ratio of 'Noisy' Pixels Per Chip (eq %d, hs %d)",eq,hs);
471 fNoisyPixelChip[hs] = new TH1F(label.Data(),label.Data(),10,-0.5,9.5);
472 fNoisyPixelChip[hs]->SetXTitle("chip");
473 fNoisyPixelChip[hs]->SetYTitle("ratio [%]");
474 fNoisyPixelChip[hs]->SetFillColor(kBlue);
475 fNoisyPixelChip[hs]->SetStats(0);
476 }
477
478}
479//_________________________________________________________________________
480void AliITSOnlineSPDscanAnalyzer::DeleteUniformityHistograms() {
481 // remove uniformity histograms if they are created
482 if (fTPeffHS!=NULL) {
483 delete fTPeffHS;
484 fTPeffHS=NULL;
485 }
486 if (fDeadPixelHS!=NULL) {
487 delete fDeadPixelHS;
488 fDeadPixelHS=NULL;
489 }
490 if (fNoisyPixelHS!=NULL) {
491 delete fNoisyPixelHS;
492 fNoisyPixelHS=NULL;
493 }
494 for (UInt_t hs=0; hs<6; hs++) {
495 if (fTPeffChip[hs]!=NULL) {
496 delete fTPeffChip[hs];
497 fTPeffChip[hs]=NULL;
498 }
499 if (fDeadPixelChip[hs]!=NULL) {
500 delete fDeadPixelChip[hs];
501 fDeadPixelChip[hs]=NULL;
502 }
503 if (fNoisyPixelChip[hs]!=NULL) {
504 delete fNoisyPixelChip[hs];
505 fNoisyPixelChip[hs]=NULL;
506 }
507 }
508}
509//_________________________________________________________________________
510Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(/*Char_t *oldcalibDir*/) {
511 // process noisy pixel data
512 if (fScanObj==NULL) {
513 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
514 return kFALSE;
515 }
516 // should be type kNOISE
517 if (fType != kNOISE) {
518 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
519 return kFALSE;
520 }
521 // handler should be initialized
522 if (fHandler==NULL) {
523 Error("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Calibration handler is not initialized!");
524 return kFALSE;
525 }
526 // check if enough statistics
527 if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
528 Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Process noisy: Too few events.");
529 return kFALSE;
530 }
531
532 UInt_t routerNr = fScanObj->GetRouterNr();
533 for (UInt_t hs=0; hs<6; hs++) {
534 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
535 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
536 if (fOverWrite) {fHandler->ResetNoisyForChip(routerNr,hs,chipNr);}
537 for (UInt_t col=0; col<32; col++) {
538 for (UInt_t row=0; row<256; row++) {
539 if (fScanObj->GetHitsEfficiency(0,hs,chipNr,col,row)>fNoiseThreshold) {
540 fHandler->SetNoisyPixel(routerNr,hs,chipNr,col,row);
541 }
542 }
543 }
544 }
545 }
546 }
547 return kTRUE;
548}
549//_________________________________________________________________________
550Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
551 // get delay
552 if (hs>=6 || chipNr>10) return -1;
553 if (fScanObj==NULL) {
554 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","No data!");
555 return -1;
556 }
557 // should be type kDELAY or kDAC with id 42 (delay_ctrl)
558 if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
559 Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","Delay only for scan type %d or %d and dac_id 42.",kDELAY,kDAC);
560 return -1;
561 }
562 if (fMeanMultiplicity[hs][chipNr]==NULL) {
563 if (!ProcessMeanMultiplicity()) {
564 return -1;
565 }
566 }
567
568 UInt_t maxStep=0;
569 Float_t maxVal=0;
570 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
571 Double_t thisDac;
572 Double_t thisMult;
573 fMeanMultiplicity[hs][chipNr]->GetPoint(step,thisDac,thisMult);
574 if (thisMult > maxVal) {
575 maxVal = thisMult;
576 maxStep = step;
577 }
578 }
579
580 if (maxVal>0) {
581 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(maxStep);
582 }
583 else {
584 return -1;
585 }
586
587}
588//_________________________________________________________________________
589Int_t AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima(UInt_t hs, UInt_t chipNr) {
590 // in case of a uniformity scan, returns the nr of noisy pixels, (here > 200 hits)
591 if (hs>=6 || chipNr>10) return -1;
592 if (fScanObj==NULL) {
593 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","No data!");
594 return kFALSE;
595 }
596 // should be type kUNIMA
597 if (fType != kUNIMA) {
598 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Noisy pixels Unima only for scan type %d.",kUNIMA);
599 return kFALSE;
600 }
601 if (fScanObj->GetTriggers(0)!=25600) {
602 Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Process noisy unima: Incorrect number of events (!=25600.");
603 return kFALSE;
604 }
605
606 Int_t nrNoisy=0;
607 if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
608 for (UInt_t col=0; col<32; col++) {
609 for (UInt_t row=0; row<256; row++) {
610 if (fScanObj->GetHits(0,hs,chipNr,col,row)>200) {
611 nrNoisy++;
612 }
613 }
614 }
615 }
616 else {
617 return -1;
618 }
619 return nrNoisy;
620}
621//_________________________________________________________________________
622Int_t AliITSOnlineSPDscanAnalyzer::FindLastMinThDac(UInt_t hs, UInt_t chipNr) {
623 // returns dac value where fMinIncreaseFromBaseLine reached
624 if (hs>=6 || chipNr>10) return -1;
625 if (fMeanMultiplicity[hs][chipNr]==NULL) {
626 if (!ProcessMeanMultiplicity()) {
627 return -1;
628 }
629 }
630 Double_t firstVal, dummy1;
631 fMeanMultiplicity[hs][chipNr]->GetPoint(0,dummy1,firstVal);
632 UInt_t step=0;
633 while (step<fScanObj->GetNSteps()-1) {
634 Double_t graphVal, dummy2;
635 fMeanMultiplicity[hs][chipNr]->GetPoint(step+1,dummy2,graphVal);
636 if (graphVal>firstVal+fMinIncreaseFromBaseLine) break;
637 step++;
638 }
639 if (step==fScanObj->GetNSteps()-1) return -1;
640 return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step);
641}
642
643Int_t AliITSOnlineSPDscanAnalyzer::FindClosestLowerStep(Float_t dacValueInput) {
644 // returns step closest (lower) to a dacvalue
645 UInt_t step=0;
646 while (step<fScanObj->GetNSteps()-1) {
647 Int_t dacVal = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1);
648 if (dacVal>=dacValueInput) break;
649 step++;
650 }
651 return step;
652}
653//_________________________________________________________________________
654Float_t AliITSOnlineSPDscanAnalyzer::GetCompareLine(UInt_t step, UInt_t hs, UInt_t chipNr, Float_t basePar2) {
655 // returns value to compare mean mult with (when finding min th)
656 if (hs>=6 || chipNr>10) return -1;
657 if (step<fMinNrStepsBeforeIncrease) return -1;
658 Float_t baseLine = basePar2;
659 if (baseLine<0) baseLine=0;
660 Float_t baseAdd;
661 Double_t baseM=0;
662 Double_t baseS=0;
663 Double_t d,m;
664 for (UInt_t st=1;st<2*step/3;st++) { // skip first point...
665 fMeanMultiplicity[hs][chipNr]->GetPoint(st,d,m);
666 baseM+=m-baseLine;
667 baseS+=(m-baseLine)*(m-baseLine);
668 }
669 baseAdd=2*sqrt( baseS/(2*step/3-1) - (baseM/(2*step/3-1))*(baseM/(2*step/3-1)) );
670 baseAdd+=0.03; // magic number
671 if (baseAdd>fMinIncreaseFromBaseLine) baseAdd=fMinIncreaseFromBaseLine;
672 return baseLine + baseAdd;
673}
674
675Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
676 // calculates and returns the minimum threshold
677 if (hs>=6 || chipNr>10) return -1;
678 if (fScanObj==NULL) {
679 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","No data!");
680 return -1;
681 }
682 // should be type kMINTH or kDAC with id 39 (pre_vth)
683 if (fType!=kMINTH && (fType!=kDAC || fDacId!=39)) {
684 Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","MinTh only for scan type %d OR %d with dac_id 39.",kMINTH,kDAC);
685 return -1;
686 }
687 if (fMeanMultiplicity[hs][chipNr]==NULL) {
688 if (!ProcessMeanMultiplicity()) {
689 return -1;
690 }
691 }
692
693 Int_t lastDac = FindLastMinThDac(hs,chipNr);
694 if (lastDac==-1) {
695 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.",hs,chipNr,fMinIncreaseFromBaseLine);
696 return -1;
697 }
698
699 Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
700 TString funcName = Form("Fit minth func HS%d CHIP%d",hs,chipNr);
701 TF1 *minThFunc = new TF1(funcName.Data(),itsSpdErrorf,100,500,3);
702 minThFunc->SetParameter(0,lastDac+10);
703 minThFunc->SetParameter(1,2);
704 minThFunc->SetParameter(2,0);
705 minThFunc->SetParName(0,"Mean");
706 minThFunc->SetParName(1,"Sigma");
707 minThFunc->SetParName(2,"BaseLine");
708 minThFunc->SetLineWidth(1);
709 if (fMeanMultiplicity[hs][chipNr]==NULL) {
710 if (!ProcessMeanMultiplicity()) {
711 return -1;
712 }
713 }
714 fMeanMultiplicity[hs][chipNr]->Fit(funcName,"Q0","",minDac,lastDac);
715
716 // Double_t mean = fMinThFunc[hs][chipNr]->GetParameter(0);
717 // Double_t sigma = fMinThFunc[hs][chipNr]->GetParameter(1);
718 Double_t baseLine = minThFunc->GetParameter(2);
719 delete minThFunc;
720
721 if (baseLine>fMaxBaseLineLevel) {
722 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f).",hs,chipNr,baseLine,fMaxBaseLineLevel);
723 return -1;
724 }
725 UInt_t step=FindClosestLowerStep(lastDac);
726 Float_t compareLine = GetCompareLine(step,hs,chipNr,baseLine);
727 if (compareLine==-1) {
728 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.",hs,chipNr,step,fMinNrStepsBeforeIncrease);
729 return -1;
730 }
731
732 Double_t mult, dummy;
733 mult=1000;
734 while (mult > compareLine && step>0) {
735 fMeanMultiplicity[hs][chipNr]->GetPoint(step,dummy,mult);
736 step--;
737 }
738 Int_t minth = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1)-fStepDownDacSafe;
739
740 if (step>0) {
741 return minth;
742 }
743 else {
744 Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Did not find a point below the compare line (%f).",hs,chipNr,compareLine);
745 return -1;
746 }
747}
748//_________________________________________________________________________
749Bool_t AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity() {
750 // process mean multiplicity data
751 if (fScanObj==NULL) {
752 Error("AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity","No data!");
753 return kFALSE;
754 }
755 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
756 for (UInt_t hs=0; hs<6; hs++) {
757 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
758 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
759 if (step==0) {
760 if (fMeanMultiplicity[hs][chipNr]!=NULL) {
761 delete fMeanMultiplicity[hs][chipNr];
762 }
763 fMeanMultiplicity[hs][chipNr] = new TGraph();
764 }
765 Float_t multiplMean=fScanObj->GetAverageMultiplicity(step,hs,chipNr);
766 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
767 fMeanMultiplicity[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),multiplMean);
768 }
769 else {
770 fMeanMultiplicity[hs][chipNr]->SetPoint(step,0,multiplMean);
771 }
772 }
773 // }
774 }
775 }
776 return kTRUE;
777}
778//_________________________________________________________________________
779TGraph* AliITSOnlineSPDscanAnalyzer::GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr) {
780 // returns mean multiplicity graph
781 if (hs>=6 || chipNr>10) return NULL;
782 if (fMeanMultiplicity[hs][chipNr]==NULL) {
783 if (!ProcessMeanMultiplicity()) {
784 return NULL;
785 }
786 }
787 return fMeanMultiplicity[hs][chipNr];
788}
789//_________________________________________________________________________
790Bool_t AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency() {
791 // process hit event efficiency
792 if (fScanObj==NULL) {
793 Error("AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency","No data!");
794 return kFALSE;
795 }
796 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
797 for (UInt_t hs=0; hs<6; hs++) {
798 for (UInt_t chipNr=0; chipNr<11; chipNr++) {
799 // if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
800 if (step==0) {
801 if (fHitEventEfficiency[hs][chipNr]!=NULL) {
802 delete fHitEventEfficiency[hs][chipNr];
803 }
804 fHitEventEfficiency[hs][chipNr] = new TGraph();
805 }
806 Float_t efficiency=fScanObj->GetHitEventsEfficiency(step,hs,chipNr);
807 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
808 fHitEventEfficiency[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),efficiency);
809 }
810 else {
811 fHitEventEfficiency[hs][chipNr]->SetPoint(step,0,efficiency);
812 }
813 }
814 // }
815 }
816 }
817 return kTRUE;
818}
819//_________________________________________________________________________
820TGraph* AliITSOnlineSPDscanAnalyzer::GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr) {
821 // returns hit event efficiency graph
822 if (hs>=6 || chipNr>10) return NULL;
823 if (fHitEventEfficiency[hs][chipNr]==NULL) {
824 if (!ProcessHitEventEfficiency()) {
825 return NULL;
826 }
827 }
828 return fHitEventEfficiency[hs][chipNr];
829}
830//_________________________________________________________________________
831Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers() {
832 // process nr of triggers data
833 if (fScanObj==NULL) {
834 Error("AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers","No data!");
835 return kFALSE;
836 }
837 for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
838 if (step==0) {
839 if (fTriggers!=NULL) {
840 delete fTriggers;
841 }
842 fTriggers = new TGraph();
843 }
844 if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
845 fTriggers->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),fScanObj->GetTriggers(step));
846 }
847 else {
848 fTriggers->SetPoint(step,0,fScanObj->GetTriggers(step));
849 }
850 }
851 return kTRUE;
852}
853//_________________________________________________________________________
854TGraph* AliITSOnlineSPDscanAnalyzer::GetNrTriggersG() {
855 // returns nr of triggers graph
856 if (fTriggers==NULL) {
857 if (!ProcessNrTriggers()) {
858 return NULL;
859 }
860 }
861 return fTriggers;
862}
863//_________________________________________________________________________
864Bool_t AliITSOnlineSPDscanAnalyzer::GetHalfStavePresent(UInt_t hs) {
865 // returns half stave present info
866 if (hs<6 && fScanObj!=NULL) {
867 Int_t chipstatus=0;
868 for (Int_t chip=0; chip<10; chip++) {
869 chipstatus+=fScanObj->GetChipPresent(hs,chip);
870 }
871 if (chipstatus>0) return kTRUE;
872 }
873 return kFALSE;
874}
875//_________________________________________________________________________
876UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
877 // returns the router nr of scan obj
878 if (fScanObj!=NULL) return fScanObj->GetRouterNr();
879 else return 99;
880}
881//_________________________________________________________________________
882TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
883 // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
884 if (fScanObj==NULL) {
885 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
886 return NULL;
887 }
888 TString histoname;
889 if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
890 histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
891 }
892 else {
893 histoname = Form("Router %d ",GetRouterNr());
894 }
895 TH2F* fHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
896 fHitMapTot->SetNdivisions(-10,"X");
897 fHitMapTot->SetNdivisions(-006,"Y");
898 fHitMapTot->SetTickLength(0,"X");
899 fHitMapTot->SetTickLength(0,"Y");
900 fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
901 fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
902 for (UInt_t hs=0; hs<6; hs++) {
903 for (UInt_t chipNr=0; chipNr<10; chipNr++) {
904 for (UInt_t col=0; col<32; col++) {
905 for (UInt_t row=0; row<256; row++) {
906 fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
907 }
908 }
909 }
910 }
911 return fHitMapTot;
912}
913//_________________________________________________________________________
914TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapChip(UInt_t step, UInt_t hs, UInt_t chip) {
915 // creates and returns a pointer to a hitmap histo (chip style a la spdmood)
916 if (fScanObj==NULL) {
917 Error("AliITSOnlineSPDscanAnalyzer::GetHitMapChip","No data!");
918 return NULL;
919 }
920
921 TString histoName;
922 TString histoTitle;
923 histoName = Form("fChipHisto_%d_%d_%d", GetRouterNr(), hs, chip);
924 histoTitle = Form("Eq ID %d, Half Stave %d, Chip %d", GetRouterNr(), hs, chip);
925
926 TH2F *returnHisto = new TH2F(histoName.Data(), histoTitle.Data(), 32, -0.5, 31.5, 256, -0.5, 255.5);
927 returnHisto->SetMinimum(0);
928 for (UInt_t col=0; col<32; col++) {
929 for (UInt_t row=0; row<256; row++) {
930 returnHisto->Fill(col,row,fScanObj->GetHits(step,hs,chip,col,row));
931 }
932 }
933
934 return returnHisto;
935}
936