ITS/AliITSQASPDDataMakerRec.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 /* $Id$  */
  16 //  *************************************************************
  17 //  Checks the quality assurance
  18 //  by comparing with reference data
  19 //  contained in a DB
  20 //  -------------------------------------------------------------
  21 //  W. Ferrarese + P. Cerello Feb 2008
  22 //  INFN Torino
  23 //  M. Nicassio D. Elia INFN Bari March 2008
  24 //  maria.nicassio@ba.infn.it
  25
  26
  27 // --- ROOT system ---
  28 #include <TTree.h>
  29 #include <TH1I.h>
  30 #include <TH1F.h>
  31 #include <TH2F.h>
  32 #include <TMath.h>
  33 // --- Standard library ---
  34
  35 // --- AliRoot header files ---
  36 #include "AliITSQADataMakerRec.h"
  37 #include "AliITSQASPDDataMakerRec.h"
  38 #include "AliLog.h"
  39 #include "AliQAv1.h"
  40 #include "AliRawReader.h"
  41 #include "AliITSRawStreamSPD.h"
  42 #include "AliITSRawStreamSPDErrorLog.h"
  43 #include "AliITSdigitSPD.h"
  44 #include "AliITSRecPoint.h"
  45 #include "AliITSRecPointContainer.h"
  46
  47 ClassImp(AliITSQASPDDataMakerRec)
  48
  49 //____________________________________________________________________________
  50 AliITSQASPDDataMakerRec::AliITSQASPDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Short_t ldc, AliITSRawStreamSPDErrorLog *aliITSRawStreamSPDErrorLog) :
  51 TObject(),
  52 fAliITSQADataMakerRec(aliITSQADataMakerRec),
  53 fkOnline(kMode),
  54 fLDC(ldc),
  55 fSPDhRawsTask(0),
  56 fSPDhDigitsTask(0),
  57 fSPDhRecPointsTask(0),
  58 fGenRawsOffset(0),
  59 fGenDigitsOffset(0),
  60 fGenRecPointsOffset(0),
  61 fAdvLogger(aliITSRawStreamSPDErrorLog)
  62 {
  63   //ctor used to discriminate OnLine-Offline analysis
  64   //AliInfo(Form("AliRecoParam::kNSpecies %d\n",AliRecoParam::kNSpecies));
  65         fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
  66         fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
  67         fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
  68         for(Int_t i=0; i<AliRecoParam::kNSpecies;i++) {
  69                 fGenRawsOffset[i] = 0;
  70                 fGenRecPointsOffset[i] = 0;
  71                 fGenDigitsOffset[i]=0;
  72         }
  73 }
  74
  75 //____________________________________________________________________________
  76 AliITSQASPDDataMakerRec::AliITSQASPDDataMakerRec(const AliITSQASPDDataMakerRec& qadm) :
  77 TObject(),
  78 fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
  79 fkOnline(qadm.fkOnline),
  80 fLDC(qadm.fLDC),
  81 fSPDhRawsTask(qadm.fSPDhRawsTask),
  82 fSPDhDigitsTask(qadm.fSPDhDigitsTask),
  83 fSPDhRecPointsTask(qadm.fSPDhRecPointsTask),
  84 fGenRawsOffset(qadm.fGenRawsOffset),
  85 fGenDigitsOffset(qadm.fGenDigitsOffset),
  86 fGenRecPointsOffset(qadm.fGenRecPointsOffset),
  87 fAdvLogger(qadm.fAdvLogger)
  88 {
  89   //copy ctor
  90   fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
  91   fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
  92   }
  93
  94 //__________________________________________________________________
  95 AliITSQASPDDataMakerRec::~AliITSQASPDDataMakerRec(){
  96   // destructor
  97 //  delete fAdvLogger;
  98 }
  99 //__________________________________________________________________
 100
 101 AliITSQASPDDataMakerRec& AliITSQASPDDataMakerRec::operator = (const AliITSQASPDDataMakerRec& qac )
 102 {
 103   // Equal operator.
 104   this->~AliITSQASPDDataMakerRec();
 105   new(this) AliITSQASPDDataMakerRec(qac);
 106   return *this;
 107 }
 108
 109 //____________________________________________________________________________
 110 void AliITSQASPDDataMakerRec::StartOfDetectorCycle()
 111 {
 112   //Detector specific actions at start of cycle
 113   AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SPD Cycle\n");
 114 }
 115
 116 //____________________________________________________________________________
 117 void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray* list)
 118 {
 119   // launch the QA checking
 120   AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
 121   if(!list){
 122   AliError(" Histogram list is NULL");
 123   return;
 124   }
 125
 126   Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
 127
 128   if(task == AliQAv1::kRAWS) {
 129   if(!list->At(0+shift)) {
 130   AliError(" no histogram 0 at the end of detector cycle in raws");
 131   return;
 132   }
 133   //((TH1I*)list->At(5+shift))->Print();
 134   ((TH1I*)list->At(5+shift))->Reset(); // clean up MEB histo (needed at the first cycles for small statistics)
 135
 136   for(Int_t eq=0; eq<20; eq++){
 137     for(Int_t hs=0; hs<6; hs++){
 138      for(Int_t chip=0; chip<10;chip++){
 139        Double_t expectedFO = ((TH1F*)list->At(0+shift))->GetBinContent(eq*60+hs*10+chip+1);// fired chips
 140       if(expectedFO){
 141       Float_t actualFO = ((TH1F*)list->At(1+shift))->GetBinContent(eq*60+hs*10+chip+1);
 142       Float_t missingFO = ((TH1F*)list->At(2+shift))->GetBinContent(eq*60+hs*10+chip+1);
 143       Float_t noisyFO = ((TH1F*)list->At(3+shift))->GetBinContent(eq*60+hs*10+chip+1);
 144       ((TH1F*)list->At(7+eq+shift))->SetBinContent(hs*10+chip+1,actualFO/expectedFO); // FO eff per eq
 145       ((TH1F*)list->At(27+eq+shift))->SetBinContent(hs*10+chip+1,missingFO/expectedFO);// missing FO per eq
 146       ((TH1F*)list->At(47+eq+shift))->SetBinContent(hs*10+chip+1,noisyFO/expectedFO); // Noisy FO per eq
 147
 148       if(noisyFO/expectedFO>0.5 && missingFO/expectedFO>0.5) {
 149       // MEB problem if the missing FO and noisy FO sugnals and BOTH above some threshold
 150       ((TH1I*)list->At(5+shift))->Fill(eq*60+hs*10+chip);
 151        }
 152       }
 153      }
 154     }
 155    }
 156
 157   }
 158   ((TH1I*)list->At(5+shift))->Print();
 159 }
 160
 161 //____________________________________________________________________________
 162 Int_t AliITSQASPDDataMakerRec::InitRaws()
 163 {
 164
 165   // Initialization for RAW data - SPD -
 166   const Bool_t expert   = kTRUE ;
 167   const Bool_t saveCorr = kTRUE ;
 168   const Bool_t image    = kTRUE ;
 169   Int_t rv = 0 ;
 170 //  fGenRawsOffset = (fAliITSQADataMakerRec->fRawsQAList[AliRecoParam::kDefault])->GetEntries();
 171
 172   if(!fAdvLogger) fAdvLogger = new AliITSRawStreamSPDErrorLog();
 173   AliDebug(AliQAv1::GetQADebugLevel(), "Book Offline Histograms for SPD\n ");
 174
 175   Char_t name[50];
 176   Char_t title[50];
 177   // offset for online histogram numbering
 178   Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
 179
 180
 181   Float_t range[2] = {-0.5,1199.};
 182
 183 // **********  online histo booking (shift is added)   *********************
 184
 185   //0
 186   TH1F *hFiredChips = new TH1F("SPDFiredChips_OnlineSPD","FiredChips - SPD",fgkSPDchips,range[0],range[1]);
 187   hFiredChips->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)");
 188   hFiredChips->GetYaxis()->SetTitle("Fired Chip yield");
 189   rv = fAliITSQADataMakerRec->Add2RawsList(hFiredChips, 0+shift, expert, !image, !saveCorr);
 190   fSPDhRawsTask++;
 191   // 1
 192   TH1F *hFastOrFiredChips = new TH1F("SPDFastOrFiredChips_OnlineSPD","FastOr-Fired Chips (if pixel hit present) - SPD",fgkSPDchips,range[0],range[1]);
 193   hFastOrFiredChips->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)");
 194   hFastOrFiredChips->GetYaxis()->SetTitle("FastOr-Fired Chip yield (per event)");
 195   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrFiredChips, 1+shift, expert, !image, !saveCorr);
 196   fSPDhRawsTask++;
 197 // 2
 198   TH1F *hFastOrMissing = new TH1F("SPDFastOrMissing_OnlineSPD","Missing FastOr signal - SPD",fgkSPDchips,range[0],range[1]);
 199   hFastOrMissing->GetXaxis()->SetTitle("chip index (eq*60 + hs*10 + chip)");
 200   hFastOrMissing->GetYaxis()->SetTitle("Missing Fast Or yield");
 201   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMissing, 2+shift, expert, !image, !saveCorr);
 202   fSPDhRawsTask++;
 203 // 3
 204   TH1F *hFastOrNoisy = new TH1F("SPDFastOrNoisy_OnlineSPD","Noisy (no pixel hit present) FastOr signal - SPD",fgkSPDchips,range[0],range[1]);
 205   hFastOrNoisy->GetXaxis()->SetTitle("chipkey");
 206   hFastOrNoisy->GetYaxis()->SetTitle("Noisy Fast Or");
 207   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrNoisy, 3+shift, expert, !image, !saveCorr);
 208   fSPDhRawsTask++;
 209 // 4
 210   TH1F *hFastOrCumulative = new TH1F("SPDFastOrCumulative_OnlineSPD","Cumulative FastOr signal - SPD",fgkSPDchips,range[0],range[1]);
 211   hFastOrCumulative->GetXaxis()->SetTitle("chipkey");
 212   hFastOrCumulative->GetYaxis()->SetTitle("Cumulative Fast Or yield");
 213   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrCumulative, 4+shift, expert, !image, !saveCorr);
 214   fSPDhRawsTask++;
 215 // 5
 216   TH1I *hSPDChipsMEB = new TH1I("SPDChipsMEB_OnlineSPD","Chips with MEB problem - SPD",fgkSPDchips,range[0],range[1]);
 217   hSPDChipsMEB->GetXaxis()->SetTitle("chipkey");
 218   hSPDChipsMEB->SetLineColor(kRed);
 219   hSPDChipsMEB->GetYaxis()->SetTitle("MEB Problem (per cycle)");
 220   rv = fAliITSQADataMakerRec->Add2RawsList(hSPDChipsMEB, 5+shift, expert, !image, !saveCorr);
 221   fSPDhRawsTask++;
 222 // 6
 223   TH2F *hFastOrCorrelation = new TH2F("SPDFastOrCorrelation_OnlineSPD","Fast Or multiplicity correlation - SPD",100,0.,100.,100,0,100);
 224   hFastOrCorrelation->GetXaxis()->SetTitle("Layer 1");
 225   hFastOrCorrelation->GetYaxis()->SetTitle("Layer 2");
 226   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrCorrelation, 6+shift, expert, !image, !saveCorr);
 227   fSPDhRawsTask++;
 228 // 7-26
 229   TH1F *hFastOrEfficiency[20], *hFastOrMissingRatio[20], *hFastOrNoisyRatio[20];
 230   for(Int_t eq =0; eq<20; eq++){
 231   hFastOrEfficiency[eq] = new TH1F(Form("SPDFastOrEfficiencyEq%i_OnlineSPD",eq),Form("FastOr Efficiency : FastOr / fired chips (per event) - Eq %i SPD",eq),60,-0.5,59.5);
 232   hFastOrEfficiency[eq]->SetFillColor(kBlue);
 233   hFastOrEfficiency[eq]->SetMaximum(1.05);
 234   hFastOrEfficiency[eq]->GetXaxis()->SetTitle("chip index [hs*10+chip]");
 235   hFastOrEfficiency[eq]->GetYaxis()->SetTitle("FastOr Efficiency (per event)");
 236   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrEfficiency[eq], 7+shift+eq, expert, !image, !saveCorr);
 237   fSPDhRawsTask++;
 238   }
 239 // 27-46
 240   for(Int_t eq=0; eq<20; eq++){
 241   hFastOrMissingRatio[eq] = new TH1F(Form("SPDFastOrMissingRatioEq%i_OnlineSPD",eq),Form(" Missing FastOr / fired chips (per event) - Eq %i - SPD)",eq),60,-0.5,59.5);
 242   hFastOrMissingRatio[eq]->SetFillColor(kBlue);
 243   hFastOrMissingRatio[eq]->SetMaximum(1.05);
 244   hFastOrMissingRatio[eq]->GetXaxis()->SetTitle("chip index [hs*10+chip]");
 245   hFastOrMissingRatio[eq]->GetYaxis()->SetTitle("ratio of Missing FastOr (per event)");
 246   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMissingRatio[eq], 27+shift+eq, expert, !image, !saveCorr);
 247   fSPDhRawsTask++;
 248   }
 249 // 47-66
 250   for(Int_t eq=0; eq<20; eq++){
 251   hFastOrNoisyRatio[eq] = new TH1F(Form("SPDFastOrNoisyRatioEq%i_OnlineSPD",eq),Form("Noisy Fast Or / fired chips (per event) - Eq %i - SPD",eq),60,-0.5,69.5);
 252   hFastOrNoisyRatio[eq]->SetFillColor(kBlue);
 253   hFastOrNoisyRatio[eq]->SetMaximum(1.05);
 254   hFastOrNoisyRatio[eq]->GetXaxis()->SetTitle("chip index [hs*10+chip]");
 255   hFastOrNoisyRatio[eq]->GetYaxis()->SetTitle("ratio of Noisy FastOr (per event)");
 256   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrNoisyRatio[eq], 47+shift+eq, expert, !image, !saveCorr);
 257   fSPDhRawsTask++;
 258   }
 259
 260 // 67
 261   TH1F *herrorsAll = new TH1F("SPDErrorsAll_OnlineSPD","Error codes - SPD",20,0.,20.);
 262   herrorsAll->GetXaxis()->SetTitle("DDL");
 263   herrorsAll->GetYaxis()->SetTitle("Entries");
 264   rv = fAliITSQADataMakerRec->Add2RawsList(herrorsAll, 67+shift, !expert, image, !saveCorr);
 265   fSPDhRawsTask++;
 266 //68-87
 267   TH1F **herrors = new TH1F*[20];
 268   for (Int_t iEq=0; iEq<20; iEq++) {
 269     sprintf(name,"SPDErrors_Eq%d_OnlineSPD",iEq+1);
 270     sprintf(title,"Error codes - SPD Eq %d",iEq+1);
 271     herrors[iEq] = new TH1F (name,title,fAdvLogger->GetNrErrorCodes(),0,fAdvLogger->GetNrErrorCodes());
 272     herrors[iEq]->SetXTitle("Error Code");
 273     herrors[iEq]->SetYTitle("Nr of errors");
 274     rv = fAliITSQADataMakerRec->Add2RawsList(herrors[iEq], 68+shift+iEq, expert, !image, !saveCorr);
 275     fSPDhRawsTask++;
 276   }
 277 //   *********   offline histo booking  (offset is added) ****************************
 278
 279  // offset for offline histogram numbering
 280   Int_t offset = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + kAmoreFoOffset + kAmoreErrorsOffset;
 281
 282  // printf("now booking offline raw data : genrawoffset %i, kAmoreOffset %i , kAmoreErrorsOffset %i -> total %i , list numbering %i\n",fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()],(Int_t)kAmoreFoOffset,(Int_t)kAmoreErrorsOffset, offset,fSPDhRawsTask);
 283 // 0
 284   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
 285   hlayer->GetXaxis()->SetTitle("Layer number");
 286   hlayer->GetYaxis()->SetTitle("Entries");
 287   rv = fAliITSQADataMakerRec->Add2RawsList(hlayer, 0+offset, expert, !image, !saveCorr);
 288   fSPDhRawsTask++;
 289
 290   TH1F **hmod = new TH1F*[2];
 291   TH2F **hhitMap = new TH2F*[20];
 292
 293
 294 // 1-2
 295   for (Int_t iLay=0; iLay<2; iLay++) {
 296     sprintf(name,"SPDModPattern_SPD%d",iLay+1);
 297     sprintf(title,"Module map - SPD Layer %d",iLay+1);
 298     hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules);
 299     hmod[iLay]->GetXaxis()->SetTitle("Module number");
 300     hmod[iLay]->GetYaxis()->SetTitle("Entries");
 301     rv = fAliITSQADataMakerRec->Add2RawsList(hmod[iLay], 1+iLay+offset, expert, !image, !saveCorr);
 302     fSPDhRawsTask++;
 303   }
 304 // 3
 305   TH2F *hHitMapHalfStaveChipSideA
 306      = new TH2F("SPDHitMapHalfStaveChipSideA_SPD","Hit map per HalfStave per Chip Side A - SPD",60,0.,60.,10,0.,10.);
 307   hHitMapHalfStaveChipSideA->GetXaxis()->SetTitle("HalfStave");
 308   hHitMapHalfStaveChipSideA->GetYaxis()->SetTitle("Chip");
 309   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipSideA, 3+offset, expert, !image, !saveCorr);
 310   fSPDhRawsTask++;
 311 // 4
 312   TH2F *hHitMapHalfStaveChipSideC
 313      = new TH2F("SPDHitMapHalfStaveChipSideC_SPD","Hit map per HalfStave per Chip Side C - SPD",60,0.,60.,10,0.,10.);
 314   hHitMapHalfStaveChipSideC->GetXaxis()->SetTitle("HalfStave");
 315   hHitMapHalfStaveChipSideC->GetYaxis()->SetTitle("Chip");
 316   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipSideC, 4+offset, expert, !image, !saveCorr);
 317   fSPDhRawsTask++;
 318  //5-24
 319   for (Int_t iDDL=0; iDDL<20; iDDL++) {
 320     sprintf(name,"SPDHitMap_SPD_DDL%d",iDDL+1);
 321     sprintf(title,"Hit map - SPD DDL %d",iDDL+1);
 322     hhitMap[iDDL]=new TH2F(name,title,320,0,10*32,1536,0,6*256);
 323     hhitMap[iDDL]->GetXaxis()->SetTitle("Column");
 324     hhitMap[iDDL]->GetYaxis()->SetTitle("Row");
 325     rv = fAliITSQADataMakerRec->Add2RawsList(hhitMap[iDDL], 5+iDDL+offset, expert, !image, !saveCorr);
 326     fSPDhRawsTask++;
 327     }
 328 // 25-26
 329   TH1F** hMultSPDhits = new TH1F*[2];
 330   for (Int_t iLay=0; iLay<2; iLay++) {
 331     sprintf(name,"SPDHitsMultiplicity_SPD%d",iLay+1);
 332     sprintf(title,"Hit multiplicity - SPD Layer %d",iLay+1);
 333     hMultSPDhits[iLay]=new TH1F(name,title,200,0.,200.);
 334     hMultSPDhits[iLay]->GetXaxis()->SetTitle("Hit multiplicity");
 335     hMultSPDhits[iLay]->GetYaxis()->SetTitle("Entries");
 336     rv = fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits[iLay], 25+iLay+offset, expert, !image, !saveCorr);
 337     fSPDhRawsTask++;
 338   }
 339 // 27
 340   TH2F *hMultSPDhits2MultSPDhits1
 341          = new TH2F("SPDHitMultCorrelation_SPD","Hit multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
 342   hMultSPDhits2MultSPDhits1->GetXaxis()->SetTitle("Hit multiplicity (Layer 1)");
 343   hMultSPDhits2MultSPDhits1->GetYaxis()->SetTitle("Hit multiplicity (Layer 2)");
 344   rv = fAliITSQADataMakerRec->Add2RawsList(hMultSPDhits2MultSPDhits1, 27+offset, !expert, image, !saveCorr);
 345   fSPDhRawsTask++;
 346 // 28
 347   TH2F *hFastOrMapHalfStaveChip
 348          = new TH2F("SPDFastOrMapHalfStaveChip_SPD","FastOr map per HalfStave per Chip - SPD",120,0.,120.,10,0.,10.);
 349   hFastOrMapHalfStaveChip->GetXaxis()->SetTitle("HalfStave");
 350   hFastOrMapHalfStaveChip->GetYaxis()->SetTitle("Chip");
 351   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrMapHalfStaveChip, 28+offset, !expert, image, !saveCorr);
 352   fSPDhRawsTask++;
 353 // 29
 354   TH1F *hFastOrFiredMap = new TH1F("SPDFastOrPattern_SPD","FastOrFiredChip map - SPD",1200,0.,1200.);
 355   hFastOrFiredMap->GetXaxis()->SetTitle("Chip number");
 356   hFastOrFiredMap->GetYaxis()->SetTitle("Entries");
 357   rv = fAliITSQADataMakerRec->Add2RawsList(hFastOrFiredMap, 29+offset, expert, !image, !saveCorr);
 358   fSPDhRawsTask++;
 359 // 30
 360   TH2F *hHitMapHalfStaveChipInner
 361      = new TH2F("SPDHitMapStaveChipInner_SPD","Hit map per Stave per Chip Inner Layer- SPD",20,0.,20.,20,0.,20.);
 362   hHitMapHalfStaveChipInner->GetXaxis()->SetTitle("SIDE C                                 SIDE A                   Chip");
 363   hHitMapHalfStaveChipInner->GetYaxis()->SetTitle("Stave in Sector S");
 364   for(Int_t ibinx =0; ibinx< hHitMapHalfStaveChipInner->GetNbinsX(); ibinx++){
 365   if(ibinx < 10) hHitMapHalfStaveChipInner->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx));
 366   else hHitMapHalfStaveChipInner->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",20-(ibinx+1)));
 367   }
 368   for(Int_t ibiny =0; ibiny< hHitMapHalfStaveChipInner->GetNbinsY(); ibiny++){
 369   if(ibiny%2==1) hHitMapHalfStaveChipInner->GetYaxis()->SetBinLabel(ibiny+1,Form(" S %i - %i",ibiny/2,ibiny%2));
 370   else hHitMapHalfStaveChipInner->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny%2));
 371   hHitMapHalfStaveChipInner->GetYaxis()->SetTitleOffset(1.4);
 372   }
 373   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipInner, 30+offset, !expert, image, !saveCorr);
 374   fSPDhRawsTask++;
 375 // 31
 376   TH2F *hHitMapHalfStaveChipOuter
 377      = new TH2F("SPDHitMapStaveChipOuter_SPD","Hit map per Stave per Chip Outer Layer - SPD",20,0.,20.,40,0.,40.);
 378   hHitMapHalfStaveChipOuter->GetXaxis()->SetTitle("SIDE C                                 SIDE A                   Chip");
 379   hHitMapHalfStaveChipOuter->GetYaxis()->SetTitle("Stave in Sector S");
 380   for(Int_t ibinx =0; ibinx< hHitMapHalfStaveChipOuter->GetNbinsX(); ibinx++){
 381   if(ibinx < 10) hHitMapHalfStaveChipOuter->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx));
 382   else hHitMapHalfStaveChipOuter->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",20-(ibinx+1)));
 383   }
 384   for(Int_t ibiny =0; ibiny< hHitMapHalfStaveChipOuter->GetNbinsY(); ibiny++){
 385   if(ibiny%4==3) hHitMapHalfStaveChipOuter->GetYaxis()->SetBinLabel(ibiny+1,Form(" S %i - %i",ibiny/4,ibiny%4+2));
 386   else hHitMapHalfStaveChipOuter->GetYaxis()->SetBinLabel(ibiny+1,Form("%i",ibiny%4+2));
 387   hHitMapHalfStaveChipOuter->GetYaxis()->SetTitleOffset(1.4);
 388   }
 389   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapHalfStaveChipOuter, 31+offset, !expert, image, !saveCorr);
 390   fSPDhRawsTask++;
 391 // 32
 392   TH1F *hHitMapChipInnerZ = new TH1F("SPDHitMapChipInnerZ_SPD","Hit map per ChipZ Inner - SPD",20,0.,20.);
 393   hHitMapChipInnerZ->GetXaxis()->SetTitle("Chip");
 394   hHitMapChipInnerZ->GetYaxis()->SetTitle("Entries");
 395   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapChipInnerZ, 32+offset, !expert, image, !saveCorr);
 396   fSPDhRawsTask++;
 397 // 33
 398   TH1F *hHitMapChipOuterZ = new TH1F("SPDHitMapChipOuterZ_SPD","Hit map per ChipZ Outer - SPD",20,0.,20.);
 399   hHitMapChipOuterZ->GetXaxis()->SetTitle("Chip");
 400   hHitMapChipOuterZ->GetYaxis()->SetTitle("Entries");
 401   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapChipOuterZ, 33+offset, !expert, image, !saveCorr);
 402   fSPDhRawsTask++;
 403 // 34
 404   TH1F *hHitMapStaveInnerPhi = new TH1F("SPDHitMapChipInnerPhi_SPD","Hit map per Stave in Phi Inner - SPD",20,0.,20.);
 405   hHitMapStaveInnerPhi->GetXaxis()->SetTitle("Stave");
 406   hHitMapStaveInnerPhi->GetYaxis()->SetTitle("Entries");
 407   for(Int_t ibinx =0; ibinx< hHitMapStaveInnerPhi->GetNbinsX(); ibinx++){
 408   if(ibinx%2==0) hHitMapStaveInnerPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i___Sector %i",ibinx%2,ibinx/2));
 409   else hHitMapStaveInnerPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%2));
 410   }
 411   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapStaveInnerPhi, 34+offset, !expert, image, !saveCorr);
 412   fSPDhRawsTask++;
 413 // 35
 414   TH1F *hHitMapStaveOuterPhi = new TH1F("SPDHitMapChipOuterPhi_SPD","Hit map per Stave in Phi Outer - SPD",40,0.,40.);
 415   hHitMapStaveOuterPhi->GetXaxis()->SetTitle("Stave");
 416   hHitMapStaveOuterPhi->GetYaxis()->SetTitle("Entries");
 417   for(Int_t ibinx =0; ibinx< hHitMapStaveOuterPhi->GetNbinsX(); ibinx++){
 418   if(ibinx%4==0) hHitMapStaveOuterPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i___Sector %i ",ibinx%4+2,ibinx/4));
 419   else hHitMapStaveOuterPhi->GetXaxis()->SetBinLabel(ibinx+1,Form("%i",ibinx%4+2));
 420   }
 421   rv = fAliITSQADataMakerRec->Add2RawsList(hHitMapStaveOuterPhi, 35+offset, !expert, image, !saveCorr);
 422   fSPDhRawsTask++;
 423
 424   //AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Raws histograms booked\n",fSPDhRawsTask));
 425   //printf("------------------         %d SPD Raws histograms booked                \n",fSPDhRawsTask);
 426   return rv ;
 427 }
 428
 429 //____________________________________________________________________________
 430 Int_t AliITSQASPDDataMakerRec::MakeRaws(AliRawReader* rawReader)
 431 {
 432   // Fill QA for RAW - SPD -
 433   Int_t rv = 0 ;
 434   if(!rawReader) {
 435    AliError("rawReader is NULL");
 436    return -1;
 437   }
 438
 439   rawReader->Reset();
 440   AliITSRawStreamSPD rawStreamSPD(rawReader);
 441   rawStreamSPD.ActivateAdvancedErrorLog(kTRUE,fAdvLogger);
 442
 443   // shift for online histos
 444   Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
 445
 446    // shift for offline histos
 447   Int_t offset = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + kAmoreFoOffset+kAmoreErrorsOffset;
 448
 449   Int_t nDigitsL1 = 0;
 450   Int_t nDigitsL2 = 0;
 451   Int_t iEq;
 452   Int_t iLayer;
 453   Int_t iHalfStave, iChip;
 454   Int_t chipKey;
 455   Int_t col, row;
 456   UInt_t module, colM, rowM;
 457   Bool_t isFiredChip[1200];
 458   for(Int_t ichK=0; ichK<1200; ichK++) isFiredChip[ichK] = kFALSE;
 459   Bool_t isOnlineFiredChip[1200];
 460   for(Int_t iOnlineKey=0; iOnlineKey<1200; iOnlineKey++) isOnlineFiredChip[iOnlineKey] = kFALSE;
 461   UInt_t nFastOr[2]={0,0};
 462
 463   while(rawStreamSPD.Next()) {
 464
 465     iEq = rawReader->GetDDLID();
 466     if (iEq>=0 && iEq<20) {
 467       iHalfStave = rawStreamSPD.GetHalfStaveNr();
 468       iChip = rawStreamSPD.GetChipAddr();
 469       col   = rawStreamSPD.GetChipCol();
 470       row   = rawStreamSPD.GetChipRow();
 471       isOnlineFiredChip[iEq*60+iHalfStave*10+iChip] = kTRUE;
 472       chipKey = rawStreamSPD.GetOfflineChipKeyFromOnline(iEq,iHalfStave,iChip);
 473       isFiredChip[chipKey] = kTRUE;
 474
 475       rawStreamSPD.OnlineToOffline(iEq, iHalfStave, iChip, col, row, module, colM, rowM);
 476
 477       if (iHalfStave>=0 && iHalfStave<2) iLayer=0;
 478       else iLayer=1;
 479
 480       fAliITSQADataMakerRec->GetRawsData(0+offset)->Fill(iLayer);
 481       if (iLayer==0) {
 482         fAliITSQADataMakerRec->GetRawsData(1+offset)->Fill(module);
 483         nDigitsL1++;
 484       } else {
 485         fAliITSQADataMakerRec->GetRawsData(2+offset)->Fill(module);
 486         nDigitsL2++;
 487       }
 488
 489       if(iEq<10) {
 490          fAliITSQADataMakerRec->GetRawsData(3+offset)->Fill(iHalfStave+iEq*6,iChip);
 491       }
 492       else       {
 493          fAliITSQADataMakerRec->GetRawsData(4+offset)->Fill(iHalfStave+(iEq-10)*6,iChip);
 494       }
 495
 496       if(iLayer==0) {
 497          if(iEq<10)  {
 498             fAliITSQADataMakerRec->GetRawsData(30+offset)->Fill(19-iChip,1-iHalfStave+iEq*2);
 499             fAliITSQADataMakerRec->GetRawsData(32+offset)->Fill(19-iChip);
 500             fAliITSQADataMakerRec->GetRawsData(34+offset)->Fill(1-iHalfStave+iEq*2);
 501          }
 502          else {
 503             fAliITSQADataMakerRec->GetRawsData(30+offset)->Fill(iChip,1-iHalfStave+(iEq-10)*2);
 504             fAliITSQADataMakerRec->GetRawsData(32+offset)->Fill(iChip);
 505             fAliITSQADataMakerRec->GetRawsData(34+offset)->Fill(1-iHalfStave+(iEq-10)*2);
 506          }
 507       }
 508       else         {
 509          if(iEq<10)  {
 510             fAliITSQADataMakerRec->GetRawsData(31+offset)->Fill(19-iChip,iHalfStave-2+iEq*4);
 511             fAliITSQADataMakerRec->GetRawsData(33+offset)->Fill(19-iChip);
 512             fAliITSQADataMakerRec->GetRawsData(35+offset)->Fill(iHalfStave-2+iEq*4);
 513          }
 514          else {
 515             fAliITSQADataMakerRec->GetRawsData(31+offset)->Fill(iChip,iHalfStave-2+(iEq-10)*4);
 516             fAliITSQADataMakerRec->GetRawsData(33+offset)->Fill(iChip);
 517             fAliITSQADataMakerRec->GetRawsData(35+offset)->Fill(iHalfStave-2+(iEq-10)*4);
 518          }
 519       }
 520       fAliITSQADataMakerRec->GetRawsData(5+iEq+offset)->Fill(colM+(module%2)*160,rowM+iHalfStave*256);
 521     }
 522   }
 523
 524   UInt_t nErrorsDDL[20];
 525
 526   for (Int_t ieq=0; ieq<20; ieq++) {
 527     nErrorsDDL[ieq] = 0;
 528
 529
 530
 531     for (UInt_t ierr=0; ierr<fAdvLogger->GetNrErrorCodes(); ierr++) {
 532       fAliITSQADataMakerRec->GetRawsData(ieq+(kAmoreFoOffset+1)+shift)->Fill(ierr,fAdvLogger->GetNrErrors(ierr,ieq));
 533       if(ierr>0) nErrorsDDL[ieq] = nErrorsDDL[ieq] + fAdvLogger->GetNrErrors(ierr,ieq);
 534     }
 535
 536    fAliITSQADataMakerRec->GetRawsData(8+offset)->Fill(ieq,nErrorsDDL[ieq]);
 537
 538     for (Int_t ihs=0; ihs<6; ihs++) {
 539       for (Int_t ichip=0; ichip<10; ichip++) {
 540       if(isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(0+shift)->Fill(ieq*60+ihs*10+ichip); // online
 541        if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) fAliITSQADataMakerRec->GetRawsData(4+shift)->Fill(ieq*60+ihs*10+ichip); // online
 542        // now filling the 3 possibile combinations
 543       if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(1+shift)->Fill(ieq*60+ihs*10+ichip); // online
 544       if(!rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(2+shift)->Fill(ieq*60+ihs*10+ichip); // online
 545       if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && !isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(3+shift)->Fill(ieq*60+ihs*10+ichip); // online
 546
 547         chipKey = rawStreamSPD.GetOfflineChipKeyFromOnline(ieq,ihs,ichip);
 548
 549         if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) {
 550           if(ihs <2) nFastOr[0]++; // online
 551           else nFastOr[1]++;       // online
 552           fAliITSQADataMakerRec->GetRawsData(28+offset)->Fill(ihs+ieq*6,ichip);
 553           fAliITSQADataMakerRec->GetRawsData(29+offset)->Fill(chipKey);
 554         }
 555       }
 556     }
 557
 558
 559   }
 560   if(fAliITSQADataMakerRec->GetRawsData(6+shift)) {
 561   fAliITSQADataMakerRec->GetRawsData(6+shift)->Fill(nFastOr[0],nFastOr[1]); // online
 562   }
 563
 564   fAdvLogger->Reset();
 565   fAliITSQADataMakerRec->GetRawsData(25+offset)->Fill(nDigitsL1);
 566   fAliITSQADataMakerRec->GetRawsData(26+offset)->Fill(nDigitsL2);
 567   fAliITSQADataMakerRec->GetRawsData(27+offset)->Fill(nDigitsL1,nDigitsL2);
 568
 569   AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2));
 570   return rv ;
 571 }
 572
 573 //____________________________________________________________________________
 574 Int_t AliITSQASPDDataMakerRec::InitDigits()
 575 {
 576   // Initialization for DIGIT data - SPD -
 577   const Bool_t expert   = kTRUE ;
 578   const Bool_t image    = kTRUE ;
 579   Int_t rv = 0 ;
 580 //  fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
 581   //fSPDhDigitsTask must be incremented by one unit every time a histogram is ADDED to the QA List
 582
 583   Char_t name[50];
 584   Char_t title[50];
 585
 586   TH1F *hlayer = new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
 587   hlayer->GetXaxis()->SetTitle("Layer number");
 588   hlayer->GetYaxis()->SetTitle("Entries");
 589   rv = fAliITSQADataMakerRec->Add2DigitsList(hlayer,fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 590   fSPDhDigitsTask++;
 591
 592   TH1F **hmod = new TH1F*[2];
 593   for (Int_t iLay=0; iLay<2; iLay++) {
 594     sprintf(name,"SPDModPattern_SPD%d",iLay+1);
 595     sprintf(title,"Module map - SPD Layer %d",iLay+1);
 596     hmod[iLay]=new TH1F(name,title,240,0,240);
 597     hmod[iLay]->GetXaxis()->SetTitle("Module number");
 598     hmod[iLay]->GetYaxis()->SetTitle("Entries");
 599     rv = fAliITSQADataMakerRec->Add2DigitsList(hmod[iLay],1+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 600     fSPDhDigitsTask++;
 601   }
 602
 603   TH1F *hcolumns = new TH1F("SPDColumns_SPD","Columns - SPD",160,0.,160.);
 604   hcolumns->GetXaxis()->SetTitle("Column number");
 605   hcolumns->GetYaxis()->SetTitle("Entries");
 606   rv = fAliITSQADataMakerRec->Add2DigitsList(hcolumns,3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 607   fSPDhDigitsTask++;
 608
 609   TH1F *hrows = new TH1F("SPDRows_SPD","Rows - SPD",256,0.,256.);
 610   hrows->GetXaxis()->SetTitle("Row number");
 611   hrows->GetYaxis()->SetTitle("Entries");
 612   rv = fAliITSQADataMakerRec->Add2DigitsList(hrows,4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 613   fSPDhDigitsTask++;
 614
 615   TH1F** hMultSPDdigits = new TH1F*[2];
 616   for (Int_t iLay=0; iLay<2; ++iLay) {
 617     sprintf(name,"SPDDigitMultiplicity_SPD%d",iLay+1);
 618     sprintf(title,"Digit multiplicity - SPD Layer %d",iLay+1);
 619     hMultSPDdigits[iLay]=new TH1F(name,title,200,0.,200.);
 620     hMultSPDdigits[iLay]->GetXaxis()->SetTitle("Digit multiplicity");
 621     hMultSPDdigits[iLay]->GetYaxis()->SetTitle("Entries");
 622     rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdigits[iLay], 5+iLay+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 623     fSPDhDigitsTask++;
 624   }
 625
 626   TH2F *hMultSPDdig2MultSPDdig1
 627     = new TH2F("SPDDigitMultCorrelation_SPD","Digit multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
 628   hMultSPDdig2MultSPDdig1->GetXaxis()->SetTitle("Digit multiplicity (Layer 1)");
 629   hMultSPDdig2MultSPDdig1->GetYaxis()->SetTitle("Digit multiplicity (Layer 2)");
 630   rv = fAliITSQADataMakerRec->Add2DigitsList(hMultSPDdig2MultSPDdig1,7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 631   fSPDhDigitsTask++;
 632
 633   AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Digits histograms booked\n",fSPDhDigitsTask));
 634   return rv ;
 635 }
 636
 637 //____________________________________________________________________________
 638 Int_t AliITSQASPDDataMakerRec::MakeDigits(TTree *digits)
 639 {
 640   // Fill QA for DIGIT - SPD -
 641   Int_t rv = 0 ;
 642
 643 //  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
 644 //  fITS->SetTreeAddress();
 645 //  TClonesArray *iITSdigits  = fITS->DigitsAddress(0);  // 0->SPD
 646   TBranch *branchD = digits->GetBranch("ITSDigitsSPD");
 647   if (!branchD) {
 648     AliError("can't get the branch with the SPD ITS digits !");
 649     return rv;
 650   }
 651   static TClonesArray statDigits("AliITSdigitSPD");
 652   TClonesArray *iITSdigits = &statDigits;
 653   branchD->SetAddress(&iITSdigits);
 654   Int_t nDigitsL1=0;
 655   Int_t nDigitsL2=0;
 656
 657   for (Int_t imod=0; imod<240; ++imod){
 658     digits->GetEvent(imod);
 659     Int_t ndigits = iITSdigits->GetEntries();
 660     if (imod<80) {
 661       fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(0.5,ndigits);
 662       fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(imod,ndigits);
 663       nDigitsL1+=ndigits;
 664     }
 665     else {
 666       fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(1,ndigits);
 667       fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(imod,ndigits);
 668       nDigitsL2+=ndigits;
 669     }
 670     for (Int_t idig=0; idig<ndigits; ++idig) {
 671       AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
 672       Int_t col=dig->GetCoord1();  // cell number z
 673       Int_t row=dig->GetCoord2();  // cell number x
 674       fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(col);
 675       fAliITSQADataMakerRec->GetDigitsData(4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(row);
 676     }
 677   }
 678   fAliITSQADataMakerRec->GetDigitsData(5+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1);
 679   fAliITSQADataMakerRec->GetDigitsData(6+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL2);
 680   fAliITSQADataMakerRec->GetDigitsData(7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1,nDigitsL2);
 681   return rv ;
 682 }
 683
 684 //____________________________________________________________________________
 685 Int_t AliITSQASPDDataMakerRec::InitRecPoints()
 686 {
 687   // Initialization for RECPOINTS - SPD -
 688   const Bool_t expert   = kTRUE ;
 689   const Bool_t image    = kTRUE ;
 690   Int_t rv = 0 ;
 691   //AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie()));
 692   //AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]));
 693 //  fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
 694   TH1F* hlayer= new TH1F("SPDLayPattern_SPD","Layer map - SPD",6,0.,6.);
 695   hlayer->GetXaxis()->SetTitle("Layer number");
 696   hlayer->GetYaxis()->SetTitle("Entries");
 697   rv = fAliITSQADataMakerRec->Add2RecPointsList(hlayer, 0+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 698   fSPDhRecPointsTask++;
 699
 700   TH1F** hmod = new TH1F*[2];
 701   TH1F** hxl  = new TH1F*[2];
 702   TH1F** hzl  = new TH1F*[2];
 703   TH1F** hxg  = new TH1F*[2];
 704   TH1F** hyg  = new TH1F*[2];
 705   TH1F** hzg  = new TH1F*[2];
 706   TH1F** hr   = new TH1F*[2];
 707   TH1F** hphi = new TH1F*[2];
 708   TH1F** hMultSPDcl = new TH1F*[2];
 709   TH2F** hNyNz    = new TH2F*[2];  // y and z cluster length
 710   TH1F** hNpixels = new TH1F*[2];  // cluster size in number of pixels
 711   TH1F** hType    = new TH1F*[2];  // cluster type according to conventional table
 712   TH2F** hPhiZ    = new TH2F*[2];
 713
 714   Float_t xlim[2]={4.5,8.};
 715   Float_t zlim[2]={15.,15.};
 716
 717   Char_t name[50];
 718   Char_t title[50];
 719   for (Int_t iLay=0;iLay<2;iLay++) {
 720     sprintf(name,"SPDModPattern_SPD%d",iLay+1);
 721     sprintf(title,"Module map - SPD Layer %d",iLay+1);
 722     hmod[iLay]=new TH1F(name,title,fgknSPDmodules,0,fgknSPDmodules);
 723     hmod[iLay]->GetXaxis()->SetTitle("Module number");
 724     hmod[iLay]->GetYaxis()->SetTitle("Entries");
 725     rv = fAliITSQADataMakerRec->Add2RecPointsList(hmod[iLay], 1+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 726     fSPDhRecPointsTask++;
 727
 728     sprintf(name,"SPDxLoc_SPD%d",iLay+1);
 729     sprintf(title,"Local x coordinate - SPD Layer %d",iLay+1);
 730     hxl[iLay]=new TH1F(name,title,100,-4.,4.);
 731     hxl[iLay]->GetXaxis()->SetTitle("Local x [cm]");
 732     hxl[iLay]->GetYaxis()->SetTitle("Entries");
 733     rv = fAliITSQADataMakerRec->Add2RecPointsList(hxl[iLay], 2+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 734     fSPDhRecPointsTask++;
 735
 736     sprintf(name,"SPDzLoc_SPD%d",iLay+1);
 737     sprintf(title,"Local z coordinate - SPD Layer %d",iLay+1);
 738     hzl[iLay]=new TH1F(name,title,100,-4.,4.);
 739     hzl[iLay]->GetXaxis()->SetTitle("Local z [cm]");
 740     hzl[iLay]->GetYaxis()->SetTitle("Entries");
 741     rv = fAliITSQADataMakerRec->Add2RecPointsList(hzl[iLay], 3+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 742     fSPDhRecPointsTask++;
 743
 744     sprintf(name,"SPDxGlob_SPD%d",iLay+1);
 745     sprintf(title,"Global x coordinate - SPD Layer %d",iLay+1);
 746     hxg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]);
 747     hxg[iLay]->GetXaxis()->SetTitle("Global x [cm]");
 748     hxg[iLay]->GetYaxis()->SetTitle("Entries");
 749     rv = fAliITSQADataMakerRec->Add2RecPointsList(hxg[iLay],4+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 750     fSPDhRecPointsTask++;
 751
 752     sprintf(name,"SPDyGlob_SPD%d",iLay+1);
 753     sprintf(title,"Global y coordinate - SPD Layer %d",iLay+1);
 754     hyg[iLay]=new TH1F(name,title,100,-xlim[iLay],xlim[iLay]);
 755     hyg[iLay]->GetXaxis()->SetTitle("Global y [cm]");
 756     hyg[iLay]->GetYaxis()->SetTitle("Entries");
 757     rv = fAliITSQADataMakerRec->Add2RecPointsList(hyg[iLay], 5+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 758     fSPDhRecPointsTask++;
 759
 760     sprintf(name,"SPDzGlob_SPD%d",iLay+1);
 761     sprintf(title,"Global z coordinate - SPD Layer %d",iLay+1);
 762     hzg[iLay]=new TH1F(name,title,150,-zlim[iLay],zlim[iLay]);
 763     hzg[iLay]->GetXaxis()->SetTitle("Global z [cm]");
 764     hzg[iLay]->GetYaxis()->SetTitle("Entries");
 765     rv = fAliITSQADataMakerRec->Add2RecPointsList(hzg[iLay], 6+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 766     fSPDhRecPointsTask++;
 767
 768     sprintf(name,"SPDr_SPD%d",iLay+1);
 769     sprintf(title,"Radius - SPD Layer %d",iLay+1);
 770     hr[iLay]=new TH1F(name,title,100,0.,10.);
 771     hr[iLay]->GetXaxis()->SetTitle("r [cm]");
 772     hr[iLay]->GetYaxis()->SetTitle("Entries");
 773     rv = fAliITSQADataMakerRec->Add2RecPointsList(hr[iLay], 7+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 774     fSPDhRecPointsTask++;
 775
 776     sprintf(name,"SPDphi_SPD%d",iLay+1);
 777     sprintf(title,"#varphi - SPD Layer %d",iLay+1);
 778     hphi[iLay]=new TH1F(name,title,1000,0.,2*TMath::Pi());
 779     hphi[iLay]->GetXaxis()->SetTitle("#varphi [rad]");
 780     hphi[iLay]->GetYaxis()->SetTitle("Entries");
 781     rv = fAliITSQADataMakerRec->Add2RecPointsList(hphi[iLay], 8+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 782     fSPDhRecPointsTask++;
 783
 784     sprintf(name,"SPDSizeYvsZ_SPD%d",iLay+1);
 785     sprintf(title,"Cluster dimension - SPD Layer %d",iLay+1);
 786     hNyNz[iLay]=new TH2F(name,title,100,0.,100.,100,0.,100.);
 787     hNyNz[iLay]->GetXaxis()->SetTitle("z length");
 788     hNyNz[iLay]->GetYaxis()->SetTitle("y length");
 789     rv = fAliITSQADataMakerRec->Add2RecPointsList(hNyNz[iLay], 9+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 790     fSPDhRecPointsTask++;
 791
 792     sprintf(name,"SPDSizeTot_SPD%d",iLay+1);
 793     sprintf(title,"Cluster size - SPD Layer %d",iLay+1);
 794     hNpixels[iLay]=new TH1F(name,title,100,0.,100.);
 795     hNpixels[iLay]->GetXaxis()->SetTitle("Cluster size");
 796     hNpixels[iLay]->GetYaxis()->SetTitle("Entries");
 797     rv = fAliITSQADataMakerRec->Add2RecPointsList(hNpixels[iLay], 10+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 798     fSPDhRecPointsTask++;
 799
 800     sprintf(name,"SPDType_SPD%d",iLay+1);
 801     sprintf(title,"Cluster type - SPD Layer %d",iLay+1);
 802     hType[iLay]=new TH1F(name,title,20,0.,20.);
 803     hType[iLay]->GetXaxis()->SetTitle("Cluster type");
 804     hType[iLay]->GetYaxis()->SetTitle("Entries");
 805     rv = fAliITSQADataMakerRec->Add2RecPointsList(hType[iLay], 11+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 806     fSPDhRecPointsTask++;
 807
 808     sprintf(name,"SPDphi_z_SPD%d",iLay+1);
 809     sprintf(title,"#varphi vs z - SPD Layer %d",iLay+1);
 810     hPhiZ[iLay]=new TH2F(name,title,150,-zlim[iLay],zlim[iLay],200,0.,2*TMath::Pi());
 811     hPhiZ[iLay]->GetXaxis()->SetTitle("Global z [cm]");
 812     hPhiZ[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
 813     rv = fAliITSQADataMakerRec->Add2RecPointsList(hPhiZ[iLay], 12+(12*iLay)+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 814     fSPDhRecPointsTask++;
 815
 816   }
 817
 818   TH2F *hrPhi=new TH2F("SPDr_phi_SPD","#varphi vs r - SPD",100,0.,10.,100,0.,2*TMath::Pi());
 819   hrPhi->GetXaxis()->SetTitle("r [cm]");
 820   hrPhi->GetYaxis()->SetTitle("#varphi [rad]");
 821   rv = fAliITSQADataMakerRec->Add2RecPointsList(hrPhi, 25+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);
 822   fSPDhRecPointsTask++;
 823
 824   TH2F *hxy=new TH2F("SPDx_y_SPD","Global y vs x - SPD",200,-10.,10.,200,-10.,10.);
 825   hxy->GetXaxis()->SetTitle("Global x [cm]");
 826   hxy->GetYaxis()->SetTitle("Global y [cm]");
 827   rv = fAliITSQADataMakerRec->Add2RecPointsList(hxy, 26+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 828   fSPDhRecPointsTask++;
 829
 830   for (Int_t iLay=0;iLay<2;iLay++) {
 831     sprintf(name,"SPDMultiplicity_SPD%d",iLay+1);
 832     sprintf(title,"Cluster multiplicity - SPD Layer %d",iLay+1);
 833     hMultSPDcl[iLay]=new TH1F(name,title,200,0.,200.);
 834     hMultSPDcl[iLay]->GetXaxis()->SetTitle("Cluster multiplicity");
 835     hMultSPDcl[iLay]->GetYaxis()->SetTitle("Entries");
 836     rv = fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl[iLay], 27+iLay+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 837     fSPDhRecPointsTask++;
 838   }
 839
 840   TH2F *hMultSPDcl2MultSPDcl1 =
 841         new TH2F("SPDMultCorrelation_SPD","Cluster multiplicity correlation - SPD",200,0.,200.,200,0.,200.);
 842   hMultSPDcl2MultSPDcl1->GetXaxis()->SetTitle("Clusters multiplicity (Layer 1)");
 843   hMultSPDcl2MultSPDcl1->GetYaxis()->SetTitle("Clusters multiplicity (Layer 2)");
 844   rv = fAliITSQADataMakerRec->Add2RecPointsList(hMultSPDcl2MultSPDcl1, 29+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
 845   fSPDhRecPointsTask++;
 846
 847   AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SPD Recs histograms booked\n",fSPDhRecPointsTask));
 848
 849   return rv ;
 850 }
 851
 852 //____________________________________________________________________________
 853 Int_t AliITSQASPDDataMakerRec::MakeRecPoints(TTree * clusterTree)
 854 {
 855   // Fill QA for RecPoints - SPD -
 856   Int_t rv = 0 ;
 857   AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
 858   TClonesArray *recpoints = rpcont->FetchClusters(0,clusterTree);
 859   if(!rpcont->GetStatusOK() || !rpcont->IsSPDActive()){
 860     AliError("can't get SPD clusters !");
 861     return rv;
 862   }
 863
 864   //AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie()));
 865   //AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]));
 866   Int_t nSPDmod = AliITSgeomTGeo::GetModuleIndex(3,1,1);
 867
 868   Float_t cluGlo[3] = {0.,0.,0.};
 869   Int_t nClusters[2] = {0,0};
 870
 871   for (Int_t iIts=0; iIts < nSPDmod; iIts++) {
 872     recpoints = rpcont->UncheckedGetClusters(iIts);
 873     Int_t nCluster = recpoints->GetEntriesFast();
 874     if(nCluster == 0)continue;
 875     // loop over clusters
 876     while(nCluster--) {
 877       AliITSRecPoint* cluster =
 878                       (AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
 879       if (cluster->GetLayer()>1)continue;
 880       Int_t lay=cluster->GetLayer();
 881       fAliITSQADataMakerRec->GetRecPointsData(0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(lay);
 882       cluster->GetGlobalXYZ(cluGlo);
 883       Float_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]);
 884         Float_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
 885         if (lay==0) {
 886           fAliITSQADataMakerRec->GetRecPointsData(1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iIts);
 887           fAliITSQADataMakerRec->GetRecPointsData(2 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalX());
 888           fAliITSQADataMakerRec->GetRecPointsData(3 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalZ());
 889           fAliITSQADataMakerRec->GetRecPointsData(4 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0]);
 890           fAliITSQADataMakerRec->GetRecPointsData(5 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[1]);
 891           fAliITSQADataMakerRec->GetRecPointsData(6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2]);
 892           fAliITSQADataMakerRec->GetRecPointsData(7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);
 893           fAliITSQADataMakerRec->GetRecPointsData(8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);
 894           fAliITSQADataMakerRec->GetRecPointsData(9 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNz(),cluster->GetNy());
 895           fAliITSQADataMakerRec->GetRecPointsData(10 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNpixels());
 896           fAliITSQADataMakerRec->GetRecPointsData(11 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetSPDclusterType());
 897           fAliITSQADataMakerRec->GetRecPointsData(12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2],phi);
 898         } else  {
 899           fAliITSQADataMakerRec->GetRecPointsData(13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iIts);
 900           fAliITSQADataMakerRec->GetRecPointsData(14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalX());
 901           fAliITSQADataMakerRec->GetRecPointsData(15 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalZ());
 902           fAliITSQADataMakerRec->GetRecPointsData(16 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0]);
 903           fAliITSQADataMakerRec->GetRecPointsData(17 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[1]);
 904           fAliITSQADataMakerRec->GetRecPointsData(18 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2]);
 905           fAliITSQADataMakerRec->GetRecPointsData(19 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);
 906           fAliITSQADataMakerRec->GetRecPointsData(20 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);
 907           fAliITSQADataMakerRec->GetRecPointsData(21 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNz(),cluster->GetNy());
 908           fAliITSQADataMakerRec->GetRecPointsData(22 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNpixels());
 909           fAliITSQADataMakerRec->GetRecPointsData(23 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetSPDclusterType());
 910           fAliITSQADataMakerRec->GetRecPointsData(24 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2],phi);
 911         }
 912         fAliITSQADataMakerRec->GetRecPointsData(25 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad,phi);
 913         fAliITSQADataMakerRec->GetRecPointsData(26 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0],cluGlo[1]);
 914
 915         nClusters[lay]++;
 916     } // end of cluster loop
 917   } // end of its "subdetector" loop
 918
 919   for (Int_t iLay=0; iLay<2; iLay++)
 920     fAliITSQADataMakerRec->GetRecPointsData(27 +iLay +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nClusters[iLay]);
 921
 922   fAliITSQADataMakerRec->GetRecPointsData(29 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nClusters[0],nClusters[1]);
 923
 924   return rv ;
 925 }
 926
 927
 928
 929 //_______________________________________________________________
 930
 931 Int_t AliITSQASPDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task,Int_t specie) const {
 932   // Returns offset number according to the specified task
 933   Int_t offset=0;
 934   if( task == AliQAv1::kRAWS ) {
 935     offset=fGenRawsOffset[specie];
 936   }
 937   else if( task == AliQAv1::kDIGITSR ) {
 938     offset=fGenDigitsOffset[specie];
 939   }
 940   else if( task == AliQAv1::kRECPOINTS ) {
 941     offset=fGenRecPointsOffset[specie];
 942   }
 943
 944   return offset;
 945 }
 946
 947 //_______________________________________________________________
 948
 949 void AliITSQASPDDataMakerRec::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset, Int_t specie) {
 950   // Returns offset number according to the specified task
 951   if( task == AliQAv1::kRAWS ) {
 952     fGenRawsOffset[specie]=offset;
 953   }
 954   else if( task == AliQAv1::kDIGITSR ) {
 955     fGenDigitsOffset[specie]=offset;
 956   }
 957   else if( task == AliQAv1::kRECPOINTS ) {
 958     fGenRecPointsOffset[specie]=offset;
 959   }
 960 }
 961
 962 //_______________________________________________________________
 963
 964 Int_t AliITSQASPDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task) const {
 965   // Returns the number of histograms associated to the specified task
 966
 967   Int_t histotot=0;
 968
 969   if( task == AliQAv1::kRAWS ) {
 970     histotot=fSPDhRawsTask;
 971   }
 972   else if( task == AliQAv1::kDIGITSR ) {
 973     histotot=fSPDhDigitsTask;
 974   }
 975   else if( task == AliQAv1::kRECPOINTS ){
 976     histotot=fSPDhRecPointsTask;
 977   }
 978
 979   return histotot;
 980 }
 981