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