Changes related to the extraction of the V0 finder into a separate class (A. Dainese...
[u/mrichter/AliRoot.git] / ITS / AliITSOnlineSPDscanAnalyzer.cxx
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
42 Double_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 //_________________________________________________________________________
52 AliITSOnlineSPDscanAnalyzer::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 //_________________________________________________________________________
77 AliITSOnlineSPDscanAnalyzer::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 //_________________________________________________________________________
111 AliITSOnlineSPDscanAnalyzer::~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 //_________________________________________________________________________
139 AliITSOnlineSPDscanAnalyzer& 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 //_________________________________________________________________________
193 void 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 //_________________________________________________________________________
234 void 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 //_________________________________________________________________________
267 void 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 //_________________________________________________________________________
289 Bool_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 //_________________________________________________________________________
298 Bool_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 //_________________________________________________________________________
338 Bool_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 //_________________________________________________________________________
428 void 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 //_________________________________________________________________________
480 void 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 //_________________________________________________________________________
510 Bool_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 //_________________________________________________________________________
550 Int_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 //_________________________________________________________________________
589 Int_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 //_________________________________________________________________________
622 Int_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
643 Int_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 //_________________________________________________________________________
654 Float_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
675 Int_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 //_________________________________________________________________________
749 Bool_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 //_________________________________________________________________________
779 TGraph* 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 //_________________________________________________________________________
790 Bool_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 //_________________________________________________________________________
820 TGraph* 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 //_________________________________________________________________________
831 Bool_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 //_________________________________________________________________________
854 TGraph* 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 //_________________________________________________________________________
864 Bool_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 //_________________________________________________________________________
876 UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
877   // returns the router nr of scan obj
878   if (fScanObj!=NULL) return fScanObj->GetRouterNr(); 
879   else return 99;
880 }
881 //_________________________________________________________________________
882 TH2F* 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 //_________________________________________________________________________
914 TH2F* 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