Adding router nr in dcs configuration file and removing ClassDef macro in AliITSOnlin...
[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 calculated.                    //
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
40 Double_t itsSpdErrorf(Double_t *x, Double_t *par){
41   if (par[2]<0) par[2]=0;
42   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.)));
43   return val;
44 }
45 //Double_t itsSpdErrorfOrig(Double_t *x, Double_t *par){
46 //  return 0.5+0.5*TMath::Erf((x[0]-par[0])/par[1]/sqrt(2.));
47 //}
48
49
50 AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const Char_t *fileName) :
51   fType(99),fDacId(99),fRouterNr(99),fFileName(fileName),fScanObj(NULL),fTriggers(NULL),
52   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
53   fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
54 {
55   // constructor
56   for (UInt_t chipNr=0; chipNr<11; chipNr++) {
57     for (UInt_t hs=0; hs<6; hs++) {
58       fMeanMultiplicity[hs][chipNr]=NULL;
59       fHitEventEfficiency[hs][chipNr]=NULL;
60     }
61   }
62   for (Int_t module=0; module<240; module++) {
63     fHandler[module]=NULL;
64   }
65
66   Init();
67 }
68
69 AliITSOnlineSPDscanAnalyzer::AliITSOnlineSPDscanAnalyzer(const AliITSOnlineSPDscanAnalyzer& handle) :
70   fType(99),fDacId(99),fRouterNr(99),fFileName("."),fScanObj(NULL),fTriggers(NULL),
71   fOverWrite(kFALSE),fNoiseThreshold(0.01),fNoiseMinimumEvents(100),
72   fMinNrStepsBeforeIncrease(5),fMinIncreaseFromBaseLine(2),fStepDownDacSafe(2),fMaxBaseLineLevel(10)
73 {
74   // copy constructor, only copies the filename (not the processed data)
75   fFileName=handle.fFileName;
76
77   fScanObj=NULL;
78   for (UInt_t chipNr=0; chipNr<11; chipNr++) {
79     for (UInt_t hs=0; hs<6; hs++) {
80       fMeanMultiplicity[hs][chipNr]=NULL;
81       fHitEventEfficiency[hs][chipNr]=NULL;
82     }
83   }
84   fTriggers=NULL;
85   for (Int_t module=0; module<240; module++) {
86     fHandler[module]=NULL;
87   }
88
89   Init();
90 }
91
92 AliITSOnlineSPDscanAnalyzer::~AliITSOnlineSPDscanAnalyzer() {
93   // destructor
94   for (UInt_t hs=0; hs<6; hs++) {
95     for (UInt_t chipNr=0; chipNr<11; chipNr++) {
96       if (fMeanMultiplicity[hs][chipNr]!=NULL) {
97         delete fMeanMultiplicity[hs][chipNr];
98       }
99       if (fHitEventEfficiency[hs][chipNr]!=NULL) {
100         delete fHitEventEfficiency[hs][chipNr];
101       }
102     }
103   }
104   if (fTriggers!=NULL) delete fTriggers;
105   if (fScanObj!=NULL) delete fScanObj;
106   for (Int_t module=0; module<240; module++) {
107     if (fHandler[module]!=NULL) {
108       delete fHandler[module];
109     }
110   }
111 }
112
113 AliITSOnlineSPDscanAnalyzer& AliITSOnlineSPDscanAnalyzer::operator=(const AliITSOnlineSPDscanAnalyzer& handle) {
114   // assignment operator, only copies the filename (not the processed data)
115   if (this!=&handle) {
116     for (UInt_t hs=0; hs<6; hs++) {
117       for (UInt_t chipNr=0; chipNr<11; chipNr++) {
118         if (fMeanMultiplicity[hs][chipNr]!=NULL) {
119           delete fMeanMultiplicity[hs][chipNr];
120         }
121         if (fHitEventEfficiency[hs][chipNr]!=NULL) {
122           delete fHitEventEfficiency[hs][chipNr];
123         }
124       }
125     }
126     if (fTriggers!=NULL) delete fTriggers;
127     if (fScanObj!=NULL) delete fScanObj;
128     for (Int_t module=0; module<240; module++) {
129       if (fHandler[module]!=NULL) {
130         delete fHandler[module];
131       }
132     }
133    
134     fFileName=handle.fFileName;
135
136     fScanObj=NULL;
137     fType=99;
138     fDacId=99;
139     fRouterNr=99;
140     for (UInt_t chipNr=0; chipNr<11; chipNr++) {
141       for (UInt_t hs=0; hs<6; hs++) {
142         fMeanMultiplicity[hs][chipNr]=NULL;
143         fHitEventEfficiency[hs][chipNr]=NULL;
144       }
145     }
146     fTriggers=NULL;
147     for (Int_t module=0; module<240; module++) {
148       fHandler[module]=NULL;
149     }
150     
151     Init();    
152   }
153   return *this;
154 }
155
156 void AliITSOnlineSPDscanAnalyzer::Init() {
157   // first checks type of container and then initializes container obj
158   FILE* fp0 = fopen(fFileName.Data(), "r");
159   if (fp0 == NULL) {
160     return;
161   }
162   else {
163     fclose(fp0);
164   }
165   fScanObj = new AliITSOnlineSPDscan(fFileName.Data());
166   fType = fScanObj->GetType();
167   fRouterNr = fScanObj->GetRouterNr();
168   delete fScanObj;
169
170   // init container
171   switch(fType) {
172   case kUNIMA:
173   case kNOISE:
174     fScanObj = new AliITSOnlineSPDscanSingle(fFileName.Data());
175     break;
176   case kMINTH:
177   case kDAC:
178   case kDELAY:
179     fScanObj = new AliITSOnlineSPDscanMultiple(fFileName.Data());
180     fDacId = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacId();
181     break;
182   case kMEANTH:
183     fScanObj = new AliITSOnlineSPDscanMeanTh(fFileName.Data());
184     fDacId = ((AliITSOnlineSPDscanMeanTh*)fScanObj)->GetDacId();
185     break;
186   default:
187     Error("AliITSOnlineSPDscanAnalyzer::Init","Type %d not defined!",fType);
188     fScanObj=NULL;
189     return;
190     break;
191   }
192
193   // set some default values (these should later be read from text file)
194   fOverWrite=kFALSE;
195   fNoiseThreshold=0.01;
196   fNoiseMinimumEvents=100;
197   fMinNrStepsBeforeIncrease=6;
198   fMinIncreaseFromBaseLine=2;
199   fStepDownDacSafe=2;
200   fMaxBaseLineLevel=10;
201
202 }
203
204 void AliITSOnlineSPDscanAnalyzer::SetParam(const Char_t *pname, const Char_t *pval) {
205   // set a parameter
206   TString name = pname;
207   TString val = pval;
208   if (name.CompareTo("fOverWrite")==0) {
209     if (val.CompareTo("YES")==0) {
210       fOverWrite = kTRUE;
211     }
212   }
213   else if (name.CompareTo("fNoiseThreshold")==0) {
214     fNoiseThreshold = val.Atof();
215   }
216   else if (name.CompareTo("fNoiseMinimumEvents")==0) {
217     fNoiseMinimumEvents = val.Atoi();
218   }
219   else if (name.CompareTo("fMinNrStepsBeforeIncrease")==0) {
220     fMinNrStepsBeforeIncrease = val.Atoi();
221   }
222   else if (name.CompareTo("fMinIncreaseFromBaseLine")==0) {
223     fMinIncreaseFromBaseLine = val.Atof();
224   }
225   else if (name.CompareTo("fStepDownDacSafe")==0) {
226     fStepDownDacSafe = val.Atoi();
227   }
228   else if (name.CompareTo("fMaxBaseLineLevel")==0) {
229     fMaxBaseLineLevel = val.Atof();
230   }
231   else {
232     Error("AliITSOnlineSPDscanAnalyzer::SetParam","Parameter %s in configuration file unknown.",name.Data());
233   }
234 }
235
236 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels(Char_t *oldcalibDir) {
237   // process dead pixel data, for uniformity scan, 
238   // NB: This will not be the general way of finding dead pixels.
239   if (fScanObj==NULL) {
240     Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","No data!");
241     return kFALSE;
242   }
243   // should be type kUNIMA
244   if (fType!=kUNIMA) {
245     Warning("AliITSOnlineSPDscanAnalyzer::ProcessDeadPixels","Dead pixels only for scan type %d.",kUNIMA);
246     return kFALSE;
247   }
248
249   UInt_t routerNr = fScanObj->GetRouterNr();
250   UInt_t rowStart = fScanObj->GetRowStart();
251   UInt_t rowEnd   = fScanObj->GetRowEnd();
252   for (UInt_t hs=0; hs<6; hs++) {
253     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
254       if (fScanObj->GetChipPresent(hs,chipNr) && fScanObj->GetAverageMultiplicity(0,hs,chipNr)>0) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
255         UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
256         for (UInt_t col=0; col<32; col++) {
257           for (UInt_t row=rowStart; row<=rowEnd; row++) {
258             if (col!=1 && col!=9 && col!=17 && col!=25) { //exclude test columns!!!
259               if (fScanObj->GetHits(0,hs,chipNr,col,row)==0) {
260                 if (!fHandler[module]) {
261                   fHandler[module] = new AliITSOnlineCalibrationSPDhandler();
262                   fHandler[module]->SetFileLocation(oldcalibDir);
263                   fHandler[module]->ReadFromFile(module);
264                   if (fOverWrite) {fHandler[module]->ResetDeadForChip(routerNr,hs,chipNr);}
265                 }
266                 fHandler[module]->SetDeadPixel(routerNr,hs,chipNr,col,row);
267               }
268             }
269           }
270         }
271       }
272     }
273   }
274   return kTRUE;
275 }
276
277
278
279 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels(Char_t *oldcalibDir) {
280   // process noisy pixel data
281   if (fScanObj==NULL) {
282     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","No data!");
283     return kFALSE;
284   }
285   // should be type kNOISE
286   if (fType != kNOISE) {
287     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Noisy pixels only for scan type %d.",kNOISE);
288     return kFALSE;
289   }
290
291   if (fScanObj->GetTriggers(0)<fNoiseMinimumEvents) {
292     Warning("AliITSOnlineSPDscanAnalyzer::ProcessNoisyPixels","Process noisy: Too few events.");
293     return kFALSE;
294   }
295   UInt_t routerNr = fScanObj->GetRouterNr();
296   for (UInt_t hs=0; hs<6; hs++) {
297     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
298       if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
299         UInt_t module = AliITSRawStreamSPD::GetModuleNumber(routerNr,hs,chipNr);
300         for (UInt_t col=0; col<32; col++) {
301           for (UInt_t row=0; row<256; row++) {
302             if (fScanObj->GetHitsEfficiency(0,hs,chipNr,col,row)>fNoiseThreshold) {
303               if (!fHandler[module]) {
304                 fHandler[module] = new AliITSOnlineCalibrationSPDhandler();
305                 fHandler[module]->SetFileLocation(oldcalibDir);
306                 fHandler[module]->ReadFromFile(module);
307                 if (fOverWrite) {fHandler[module]->ResetNoisyForChip(routerNr,hs,chipNr);}
308               }
309               fHandler[module]->SetNoisyPixel(routerNr,hs,chipNr,col,row);
310             }
311           }
312         }
313       }
314     }
315   }
316   return kTRUE;
317 }
318
319 Bool_t AliITSOnlineSPDscanAnalyzer::SaveDeadNoisyPixels(UInt_t module, Char_t *calibDir) {
320   // save dead and noisy pixels to file in dir calibDir
321   if (fHandler[module]!=NULL) {
322     fHandler[module]->SetFileLocation(calibDir);
323     fHandler[module]->WriteToFile(module);
324     return kTRUE;
325   }
326   return kFALSE;
327 }
328
329
330 Int_t AliITSOnlineSPDscanAnalyzer::GetDelay(UInt_t hs, UInt_t chipNr) {
331   // get delay
332   if (hs>=6 || chipNr>10) return -1;
333   if (fScanObj==NULL) {
334     Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","No data!");
335     return -1;
336   }
337   // should be type kDELAY or kDAC with id 42 (delay_ctrl)
338   if (fType!=kDELAY && (fType!=kDAC || fDacId!=42)) {
339     Warning("AliITSOnlineSPDscanAnalyzer::GetDelay","Delay only for scan type %d or %d and dac_id 42.",kDELAY,kDAC);
340     return -1;
341   }
342   if (fMeanMultiplicity[hs][chipNr]==NULL) {
343     if (!ProcessMeanMultiplicity()) {
344       return -1;
345     }
346   }
347
348   UInt_t maxStep=0;
349   Float_t maxVal=0;
350   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
351     Double_t thisDac;
352     Double_t thisMult;
353     fMeanMultiplicity[hs][chipNr]->GetPoint(step,thisDac,thisMult);
354     if (thisMult > maxVal) {
355       maxVal = thisMult;
356       maxStep = step;
357     }
358   }
359
360   if (maxVal>0) {
361     return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(maxStep);
362   }
363   else {
364     return -1;
365   }
366
367 }
368
369
370 Int_t AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima(UInt_t hs, UInt_t chipNr) {
371   // in case of a uniformity scan, returns the nr of noisy pixels, (here > 200 hits)
372   if (hs>=6 || chipNr>10) return -1;
373   if (fScanObj==NULL) {
374     Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","No data!");
375     return kFALSE;
376   }
377   // should be type kUNIMA
378   if (fType != kUNIMA) {
379     Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Noisy pixels Unima only for scan type %d.",kUNIMA);
380     return kFALSE;
381   }
382   if (fScanObj->GetTriggers(0)!=25600) {
383     Error("AliITSOnlineSPDscanAnalyzer::GetNrNoisyUnima","Process noisy unima: Incorrect number of events (!=25600.");
384     return kFALSE;
385   }
386
387   Int_t nrNoisy=0;
388   if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
389     for (UInt_t col=0; col<32; col++) {
390       for (UInt_t row=0; row<256; row++) {
391         if (fScanObj->GetHits(0,hs,chipNr,col,row)>200) {
392           nrNoisy++;
393         }
394       }
395     }
396   }
397   else {
398     return -1;
399   }
400   return nrNoisy;
401 }
402
403 Int_t AliITSOnlineSPDscanAnalyzer::FindLastMinThDac(UInt_t hs, UInt_t chipNr) {
404   // returns dac value where fMinIncreaseFromBaseLine reached
405   if (hs>=6 || chipNr>10) return -1;
406   if (fMeanMultiplicity[hs][chipNr]==NULL) {
407     if (!ProcessMeanMultiplicity()) {
408       return -1;
409     }
410   }
411   Double_t firstVal, dummy1;
412   fMeanMultiplicity[hs][chipNr]->GetPoint(0,dummy1,firstVal);
413   UInt_t step=0;
414   while (step<fScanObj->GetNSteps()-1) {
415     Double_t graphVal, dummy2;
416     fMeanMultiplicity[hs][chipNr]->GetPoint(step+1,dummy2,graphVal);
417     if (graphVal>firstVal+fMinIncreaseFromBaseLine) break;
418     step++;
419   }
420   if (step==fScanObj->GetNSteps()-1) return -1;
421   return ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step);
422 }
423
424 Int_t AliITSOnlineSPDscanAnalyzer::FindClosestLowerStep(Float_t dacValueInput) {
425   // returns step closest (lower) to a dacvalue 
426   UInt_t step=0;
427   while (step<fScanObj->GetNSteps()-1) {
428     Int_t dacVal = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1);
429     if (dacVal>=dacValueInput) break;
430     step++;
431   }
432   return step;
433 }
434
435 Float_t AliITSOnlineSPDscanAnalyzer::GetCompareLine(UInt_t step, UInt_t hs, UInt_t chipNr, Float_t basePar2) {
436   // returns value to compare mean mult with (when finding min th)
437   if (hs>=6 || chipNr>10) return -1;
438   if (step<fMinNrStepsBeforeIncrease) return -1;
439   Float_t baseLine = basePar2;
440   if (baseLine<0) baseLine=0;
441   Float_t baseAdd;
442   Double_t baseM=0;
443   Double_t baseS=0;
444   Double_t d,m;
445   for (UInt_t st=1;st<2*step/3;st++) { // skip first point...
446     fMeanMultiplicity[hs][chipNr]->GetPoint(st,d,m);
447     baseM+=m-baseLine;
448     baseS+=(m-baseLine)*(m-baseLine);
449   }
450   baseAdd=2*sqrt( baseS/(2*step/3-1) - (baseM/(2*step/3-1))*(baseM/(2*step/3-1)) );
451   baseAdd+=0.03; // magic number
452   if (baseAdd>fMinIncreaseFromBaseLine) baseAdd=fMinIncreaseFromBaseLine;
453   return baseLine + baseAdd;
454 }
455
456 Int_t AliITSOnlineSPDscanAnalyzer::GetMinTh(UInt_t hs, UInt_t chipNr) {
457   // calculates and returns the minimum threshold
458   if (hs>=6 || chipNr>10) return -1;
459   if (fScanObj==NULL) {
460     Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","No data!");
461     return -1;
462   }
463   // should be type  kMINTH  or  kDAC with id 39 (pre_vth)
464   if (fType!=kMINTH && (fType!=kDAC || fDacId!=39)) {
465     Error("AliITSOnlineSPDscanAnalyzer::GetMinTh","MinTh only for scan type %d OR %d with dac_id 39.",kMINTH,kDAC);
466     return -1;
467   }
468   if (fMeanMultiplicity[hs][chipNr]==NULL) {
469     if (!ProcessMeanMultiplicity()) {
470       return -1;
471     }
472   }
473
474   Int_t lastDac = FindLastMinThDac(hs,chipNr);
475   if (lastDac==-1) {
476     Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Increase of Mean Multiplicity by %1.2f never reached.",hs,chipNr,fMinIncreaseFromBaseLine);
477     return -1;
478   }
479
480   Int_t minDac = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(0);
481   TString funcName = Form("Fit minth func HS%d CHIP%d",hs,chipNr);
482   TF1 *minThFunc = new TF1(funcName.Data(),itsSpdErrorf,100,500,3);
483   minThFunc->SetParameter(0,lastDac+10);
484   minThFunc->SetParameter(1,2);
485   minThFunc->SetParameter(2,0);
486   minThFunc->SetParName(0,"Mean");
487   minThFunc->SetParName(1,"Sigma");
488   minThFunc->SetParName(2,"BaseLine");
489   minThFunc->SetLineWidth(1);
490   if (fMeanMultiplicity[hs][chipNr]==NULL) {
491     if (!ProcessMeanMultiplicity()) {
492       return -1;
493     }
494   }
495   fMeanMultiplicity[hs][chipNr]->Fit(funcName,"Q0","",minDac,lastDac);
496
497   //  Double_t mean = fMinThFunc[hs][chipNr]->GetParameter(0);
498   //  Double_t sigma = fMinThFunc[hs][chipNr]->GetParameter(1);
499   Double_t baseLine = minThFunc->GetParameter(2);
500   delete minThFunc;
501
502   if (baseLine>fMaxBaseLineLevel) {
503     Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: BaseLine too large (%1.2f>%1.2f).",hs,chipNr,baseLine,fMaxBaseLineLevel);
504     return -1;
505   }
506   UInt_t step=FindClosestLowerStep(lastDac);
507   Float_t compareLine = GetCompareLine(step,hs,chipNr,baseLine);
508   if (compareLine==-1) {
509     Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Not enough steps (%d<%d) before increase to get a compare line.",hs,chipNr,step,fMinNrStepsBeforeIncrease);
510     return -1;
511   }
512
513   Double_t mult, dummy;
514   mult=1000;
515   while (mult > compareLine && step>0) {
516     fMeanMultiplicity[hs][chipNr]->GetPoint(step,dummy,mult);
517     step--;
518   }
519   Int_t minth = ((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step+1)-fStepDownDacSafe;
520
521   if (step>0) {
522     return minth;
523   }
524   else {
525     Warning("AliITSOnlineSPDscanAnalyzer::GetMinTh","HS%d, Chip%d: Did not find a point below the compare line (%f).",hs,chipNr,compareLine);
526     return -1;
527   }
528 }
529
530
531
532 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity() {
533   // process mean multiplicity data
534   if (fScanObj==NULL) {
535     Error("AliITSOnlineSPDscanAnalyzer::ProcessMeanMultiplicity","No data!");
536     return kFALSE;
537   }
538   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
539     for (UInt_t hs=0; hs<6; hs++) {
540       for (UInt_t chipNr=0; chipNr<11; chipNr++) {
541         //      if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
542         if (step==0) {
543           if (fMeanMultiplicity[hs][chipNr]!=NULL) {
544             delete fMeanMultiplicity[hs][chipNr];
545           }
546           fMeanMultiplicity[hs][chipNr] = new TGraph();
547         }
548         Float_t multiplMean=fScanObj->GetAverageMultiplicity(step,hs,chipNr);
549         if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
550           fMeanMultiplicity[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),multiplMean);
551         }
552         else {
553           fMeanMultiplicity[hs][chipNr]->SetPoint(step,0,multiplMean);
554         }
555       }
556       //      }
557     }
558   }
559   return kTRUE;
560 }
561
562 TGraph* AliITSOnlineSPDscanAnalyzer::GetMeanMultiplicityG(UInt_t hs, UInt_t chipNr) {
563   // returns mean multiplicity graph
564   if (hs>=6 || chipNr>10) return NULL;
565   if (fMeanMultiplicity[hs][chipNr]==NULL) {
566     if (!ProcessMeanMultiplicity()) {
567       return NULL;
568     }
569   }
570   return fMeanMultiplicity[hs][chipNr];
571 }
572
573 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency() {
574   // process hit event efficiency
575   if (fScanObj==NULL) {
576     Error("AliITSOnlineSPDscanAnalyzer::ProcessHitEventEfficiency","No data!");
577     return kFALSE;
578   }
579   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
580     for (UInt_t hs=0; hs<6; hs++) {
581       for (UInt_t chipNr=0; chipNr<11; chipNr++) {
582         //      if (fScanObj->GetChipPresent(hs,chipNr)) { // check the status of the chippresent parameter in the mood header!!!!!!!!!!!!!!!!!!!!!!!!!!!!
583         if (step==0) {
584           if (fHitEventEfficiency[hs][chipNr]!=NULL) {
585             delete fHitEventEfficiency[hs][chipNr];
586           }
587           fHitEventEfficiency[hs][chipNr] = new TGraph();
588         }
589         Float_t efficiency=fScanObj->GetHitEventsEfficiency(step,hs,chipNr);
590         if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
591           fHitEventEfficiency[hs][chipNr]->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),efficiency);
592         }
593         else {
594           fHitEventEfficiency[hs][chipNr]->SetPoint(step,0,efficiency);
595         }
596       }
597       //      }
598     }
599   }
600   return kTRUE;
601 }
602
603 TGraph* AliITSOnlineSPDscanAnalyzer::GetHitEventEfficiencyG(UInt_t hs, UInt_t chipNr) {
604   // returns hit event efficiency graph
605   if (hs>=6 || chipNr>10) return NULL;
606   if (fHitEventEfficiency[hs][chipNr]==NULL) {
607     if (!ProcessHitEventEfficiency()) {
608       return NULL;
609     }
610   }
611   return fHitEventEfficiency[hs][chipNr];
612 }
613
614
615 Bool_t AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers() {
616   // process nr of triggers data
617   if (fScanObj==NULL) {
618     Error("AliITSOnlineSPDscanAnalyzer::ProcessNrTriggers","No data!");
619     return kFALSE;
620   }
621   for (UInt_t step=0; step<fScanObj->GetNSteps(); step++) {
622     if (step==0) {
623       if (fTriggers!=NULL) {
624         delete fTriggers;
625       }
626       fTriggers = new TGraph();
627     }
628     if (fType==kMINTH || fType==kMEANTH || fType==kDAC || fType==kDELAY) {
629       fTriggers->SetPoint(step,((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step),fScanObj->GetTriggers(step));
630     }
631     else {
632       fTriggers->SetPoint(step,0,fScanObj->GetTriggers(step));
633     }
634   }
635   return kTRUE;
636 }
637
638 TGraph* AliITSOnlineSPDscanAnalyzer::GetNrTriggersG() {
639   // returns nr of triggers graph
640   if (fTriggers==NULL) {
641     if (!ProcessNrTriggers()) {
642       return NULL;
643     }
644   }
645   return fTriggers;
646 }
647
648 Bool_t AliITSOnlineSPDscanAnalyzer::GetHalfStavePresent(UInt_t hs) {
649   // returns half stave present info
650   if (hs<6 && fScanObj!=NULL) {
651     Int_t chipstatus=0;
652     for (Int_t chip=0; chip<10; chip++) {
653       chipstatus+=fScanObj->GetChipPresent(hs,chip);
654     }
655     if (chipstatus>0) return kTRUE;
656   }
657   return kFALSE;
658 }
659
660 AliITSOnlineCalibrationSPDhandler* AliITSOnlineSPDscanAnalyzer::GetOnlineCalibrationHandler(UInt_t module) {
661   // returns a pointer to the AliITSOnlineCalibrationSPDhandler
662   if (module<240) return fHandler[module]; 
663   else return NULL;
664 }
665
666 UInt_t AliITSOnlineSPDscanAnalyzer::GetRouterNr() {
667   // returns the router nr of scan obj
668   if (fScanObj!=NULL) return fScanObj->GetRouterNr(); 
669   else return 99;
670 }
671
672 TH2F* AliITSOnlineSPDscanAnalyzer::GetHitMapTot(UInt_t step) {
673   // creates and returns a pointer to a hitmap histo (half sector style a la spdmood)
674   if (fScanObj==NULL) {
675     Error("AliITSOnlineSPDscanAnalyzer::GetHitMapTot","No data!");
676     return NULL;
677   }
678   TString histoname;
679   if (fType==kMINTH || fType==kMEANTH || fType==kDAC) {
680     histoname = Form("Router %d , DAC %d",GetRouterNr(),((AliITSOnlineSPDscanMultiple*)fScanObj)->GetDacValue(step));
681   }
682   else {
683     histoname = Form("Router %d ",GetRouterNr());
684   }
685   TH2F* fHitMapTot = new TH2F(histoname.Data(),histoname.Data(),32*10,-0.5,32*10-0.5,256*6,-0.5,256*6-0.5);
686   fHitMapTot->SetNdivisions(-10,"X");
687   fHitMapTot->SetNdivisions(-006,"Y");
688   fHitMapTot->SetTickLength(0,"X");
689   fHitMapTot->SetTickLength(0,"Y");
690   fHitMapTot->GetXaxis()->SetLabelColor(gStyle->GetCanvasColor());
691   fHitMapTot->GetYaxis()->SetLabelColor(gStyle->GetCanvasColor());
692   for (UInt_t hs=0; hs<6; hs++) {
693     for (UInt_t chipNr=0; chipNr<10; chipNr++) {
694       for (UInt_t col=0; col<32; col++) {
695         for (UInt_t row=0; row<256; row++) {
696           fHitMapTot->Fill(chipNr*32+col,(5-hs)*256+row,fScanObj->GetHits(step,hs,chipNr,col,row));
697         }
698       }
699     }
700   }
701   return fHitMapTot;
702 }