ITS/AliITSQASSDDataMakerRec.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
  24 // --- ROOT system ---
  25 #include <TH2D.h>
  26 #include <TTree.h>
  27 #include <TMath.h>
  28 #include <TString.h>
  29 #include <TSystem.h>
  30
  31 // --- Standard library ---
  32
  33 // --- AliRoot header files ---
  34 #include "AliITSQASSDDataMakerRec.h"
  35 #include "AliQADataMakerRec.h"
  36 #include "AliLog.h"
  37 #include "AliQA.h"
  38 #include "AliQAChecker.h"
  39 #include "AliRawReader.h"
  40 #include "AliRawReaderRoot.h"
  41 #include "AliITSRawStreamSSD.h"
  42 #include "AliITSgeomTGeo.h"
  43 #include "AliRawEventHeaderBase.h"
  44 #include "AliITSRecPoint.h"
  45 #include "AliITSBadChannelsSSDv2.h"
  46
  47 #include "AliCDBManager.h"
  48 #include "AliCDBEntry.h"
  49
  50 ClassImp(AliITSQASSDDataMakerRec)
  51
  52 AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :
  53 TObject(),
  54 fAliITSQADataMakerRec(aliITSQADataMakerRec),
  55 fSSDEvent(0),
  56 fSSDEventPerCycle(0),
  57 fkOnline(kMode),
  58 fLDC(ldc),
  59 fSSDRawsOffset(0), fSSDRawsDAOffset(0),
  60 fSSDRawsCommonLevelOffset(0),
  61 fSSDhTask(0),
  62 fGenOffset(0),
  63 fCDBManager(0) {
  64   // Default constructor
  65   //initilize the raw signal vs strip number histograms
  66   if(fkOnline) {
  67     fCDBManager = AliCDBManager::Instance();
  68     //fCDBManager->SetDefaultStorage("local://$ALICE_ROOT");
  69     fCDBManager->SetDefaultStorage(gSystem->Getenv("AMORE_CDB_URI"));
  70     Int_t runNumber = atoi(gSystem->Getenv("DATE_RUN_NUMBER"));
  71     if(!runNumber)
  72       AliInfo("DATE_RUN_NUMBER not defined!!!\n");
  73
  74     fCDBManager->SetRun(runNumber);
  75     AliCDBEntry *geomGRP = fCDBManager->Get("GRP/Geometry/Data");
  76     if(!geomGRP) AliInfo("GRP geometry not found!!!\n");
  77
  78     Int_t gLayer = 0,gLadder = 0, gModule = 0;
  79     Int_t gHistCounter = 0;
  80     TString gTitle;
  81
  82     for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
  83       AliITSgeomTGeo::GetModuleId(iModule,gLayer,gLadder,gModule);
  84       gTitle = "SSD_RawSignal_Layer"; gTitle += gLayer;
  85       gTitle += "_Ladder"; gTitle += gLadder;
  86       gTitle += "_Module"; gTitle += gModule;
  87       fHistSSDRawSignalModule[gHistCounter] = new TH1D(gTitle.Data(),gTitle.Data(),
  88                                                        2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
  89       gHistCounter += 1;
  90
  91       for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)
  92         fOccupancyMatrix[iModule-500][iStrip] = 0;
  93     }//module loop
  94   }//online flag
  95   else {
  96     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
  97       fHistSSDRawSignalModule[iModule]=NULL;
  98     fCDBManager = NULL;
  99   }
 100 }
 101
 102 //____________________________________________________________________________
 103 AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :
 104 TObject(),
 105 fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
 106 fSSDEvent(qadm.fSSDEvent),
 107 fSSDEventPerCycle(qadm.fSSDEventPerCycle),
 108 fkOnline(qadm.fkOnline),
 109 fLDC(qadm.fLDC),
 110 fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset),
 111 fSSDRawsCommonLevelOffset(qadm.fSSDRawsCommonLevelOffset),
 112 fSSDhTask(qadm.fSSDhTask),
 113 fGenOffset(qadm.fGenOffset),
 114 fCDBManager(qadm.fCDBManager) {
 115   //copy ctor
 116   fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
 117   fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
 118 }
 119
 120 //__________________________________________________________________
 121 AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )
 122 {
 123   // Equal operator.
 124   this->~AliITSQASSDDataMakerRec();
 125   new(this) AliITSQASSDDataMakerRec(qac);
 126   return *this;
 127 }
 128
 129 //__________________________________________________________________
 130 AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() {
 131   // destructor
 132   for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
 133     if(fHistSSDRawSignalModule[iModule]) delete fHistSSDRawSignalModule[iModule];
 134   if(fCDBManager) delete fCDBManager;
 135 }
 136
 137 //____________________________________________________________________________
 138 void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
 139 {
 140   if (  fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
 141     return ;
 142
 143   //Detector specific actions at start of cycle
 144   AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
 145
 146   //Data size per DDL
 147   ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->Reset();
 148   //Data size per LDC
 149   ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->Reset();
 150
 151   //online part
 152   if(fkOnline) {
 153     for(Int_t iModule = 500; iModule < fgkSSDMODULES + 500; iModule++) {
 154       for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)
 155         fOccupancyMatrix[iModule-500][iStrip] = 0;
 156     }//module loop
 157
 158     Int_t gHistPositionOccupancyPerLadder = 0;
 159     Int_t gLayer = 0, gLadder = 0, gModule = 0;
 160     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 161       AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
 162
 163       gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
 164
 165       //P-SIDE OCCUPANCY
 166       fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();
 167       //N-SIDE OCCUPANCY
 168       fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();
 169
 170       ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset();
 171       ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset();
 172     }//module loop
 173   }//online flag
 174 }
 175
 176 //____________________________________________________________________________
 177 void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list)
 178 {
 179   // launch the QA checking
 180   if (  fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
 181     return ;
 182
 183   // launch the QA checking
 184   AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
 185   //Data size per DDL
 186   for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
 187     Double_t gSizePerDDL = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->GetMean())/1e+06;
 188     ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4)))->SetBinContent(i+2,gSizePerDDL);
 189   }
 190
 191   //Data size per LDC
 192   for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
 193     Double_t gSizePerLDC = TMath::Power(10,(fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->GetMean())/1e+06;
 194     ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22)))->SetBinContent(i+6,gSizePerLDC);
 195   }
 196
 197   //online part
 198   if(fkOnline) {
 199     //Output of the DA
 200     MonitorOCDBObjects();
 201
 202     Int_t gHistPositionOccupancyPerModule = 0;
 203     Int_t gLayer = 0, gLadder = 0, gModule = 0;
 204     //occupancy per module
 205     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 206       AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
 207
 208       gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
 209       for(Int_t iBins = 1; iBins < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBins++)
 210         fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)->SetBinContent(iBins,fOccupancyMatrix[iModule][iBins-1]);
 211
 212       if(fSSDEventPerCycle != 0)
 213         ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)))->Scale(100./fSSDEventPerCycle);
 214     }//module loop
 215
 216     //occupancy per ladder
 217     Int_t gHistPositionOccupancyPerLadder = 0;
 218     Int_t lLadderLocationY = 0;
 219     Double_t occupancy = 0.0, occupancyThreshold = 0.0, occupancyAverage = 0.0;
 220     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 221       AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
 222
 223       gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
 224       gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
 225
 226       //P-SIDE OCCUPANCY
 227       occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,0,0);
 228       occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,1,3);
 229       occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,2,0);
 230
 231       fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Fill(gModule,occupancy);
 232       lLadderLocationY = 3*gLadder; // sideP=1 sideN=0
 233       if(gLayer == 5) {
 234         //occupancy per module - no threshold
 235         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY,occupancy);
 236         //occupancy per module - threshold @ 3%
 237         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
 238         //average occupancy per module
 239         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
 240       }
 241       else if(gLayer == 6) {
 242         //occupancy per module - no threshold
 243         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY,occupancy);
 244         //occupancy per module - threshold @ 3%
 245         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
 246         //average occupancy per module
 247         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
 248       }
 249
 250       //N-SIDE OCCUPANCY
 251       occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,0,0);
 252       occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,1,3);
 253       occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,2,0);
 254
 255       fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Fill(gModule,occupancy);
 256       if(gLayer == 5) {
 257         //occupancy per module - no threshold
 258         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY-1,occupancy);
 259         //occupancy per module - threshold @ 3%
 260         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
 261         //average occupancy per module
 262         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
 263       }
 264       else if(gLayer == 6) {
 265         //occupancy per module - no threshold
 266         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY-1,occupancy);
 267         //occupancy per module - threshold @ 3%
 268         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
 269         //average occupancy per module
 270         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
 271       }
 272     }//module loop
 273   }//online flag for SSD
 274
 275   fSSDEventPerCycle = 0;
 276
 277   AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
 278 }
 279
 280 //____________________________________________________________________________
 281 void AliITSQASSDDataMakerRec::InitRaws() {
 282   // Initialization for RAW data - SSD -
 283     fGenOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries();
 284
 285   if(fkOnline) {
 286     AliInfo("Book Online Histograms for SSD\n");
 287   }
 288   else {
 289     AliInfo("Book Offline Histograms for SSD\n ");
 290   }
 291   AliInfo(Form("Number of histograms (SPD+SDD): %d\n",fGenOffset));
 292   TString gTitle = 0;
 293   //book online-offline QA histos
 294   TH1F *fHistSSDEventType = new TH1F("SSD/DataSize/fHistSSDEventType",
 295                                      ";Event type;Events",
 296                                      31,-1,30);
 297   fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType,
 298                                       fGenOffset+fSSDRawsOffset, kTRUE);
 299   fSSDRawsOffset += 1;
 300   TH1F *fHistSSDDataSize = new TH1F("SSD/DataSize/fHistSSDDataSize",
 301                                     ";log(SSD data size) [Bytes];Events",
 302                                     100,3,8);
 303   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize,
 304                                       fGenOffset+fSSDRawsOffset, kTRUE);
 305   fSSDRawsOffset += 1;
 306   TH1F *fHistSSDDataSizePercentage = new TH1F("SSD/DataSize/fHistSSDDataSizePercentage",
 307                                               ";SSD data size [%];Events",
 308                                               100,0,100);
 309   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage,
 310                                       fGenOffset+fSSDRawsOffset, kTRUE);
 311   fSSDRawsOffset += 1;
 312   TH1F *fHistSSDDDLId = new TH1F("SSD/DDL/fHistSSDDDLId",
 313                                  ";DDL id;Events",20,510.5,530.5);
 314   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId,
 315                                       fGenOffset+fSSDRawsOffset, kTRUE);
 316   fSSDRawsOffset += 1;
 317   TH1F *fHistSSDDataSizePerDDL = new TH1F("SSD/DataSize/fHistSSDDataSizePerDDL",
 318                                           ";DDL id;<SSD data size> [MB]",
 319                                           20,510.5,530.5);
 320   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL,
 321                                       fGenOffset+fSSDRawsOffset);
 322   fSSDRawsOffset += 1;
 323   TH1F *fHistSSDDataSizeDDL[fgkNumOfDDLs];
 324   for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) {
 325     gTitle = "SSD/DDL/fHistSSDDataSizeDDL"; gTitle += i+511;
 326     fHistSSDDataSizeDDL[i-1] = new TH1F(gTitle.Data(),
 327                                         ";log(SSD data size) [Bytes];Events",
 328                                         100,1,8);
 329     fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1],
 330                                         fGenOffset+fSSDRawsOffset, kTRUE);
 331     fSSDRawsOffset += 1;
 332   }
 333
 334   TH1F *fHistSSDLDCId = new TH1F("SSD/LDC/fHistSSDLDCId",";LDC id;Events",10,0.5,10.5);
 335   fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId,
 336                                       fGenOffset+fSSDRawsOffset, kTRUE);
 337   fSSDRawsOffset += 1;
 338   TH1F *fHistSSDDataSizePerLDC = new TH1F("SSD/DataSize/fHistSSDDataSizePerLDC",
 339                                           ";LDC id;<SSD data size> [MB]",
 340                                           20,0.5,20.5);
 341   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC,
 342                                       fGenOffset+fSSDRawsOffset);
 343   fSSDRawsOffset += 1;
 344   TH1F *fHistSSDDataSizeLDC[fgkNumOfLDCs];
 345   for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) {
 346     gTitle = "SSD/LDC/fHistSSDDataSizeLDC";
 347     if(i == 1) gTitle += "082";
 348     if(i == 2) gTitle += "086";
 349     if(i == 3) gTitle += "085";
 350     fHistSSDDataSizeLDC[i-1] = new TH1F(gTitle.Data(),
 351                                         ";log(SSD data size) [Bytes];Events",
 352                                         100,1,8);
 353     fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1],
 354                                         fGenOffset+fSSDRawsOffset, kTRUE);
 355     fSSDRawsOffset += 1;
 356   }
 357   fSSDRawsCommonLevelOffset = fSSDRawsOffset;
 358
 359   if(fkOnline) {
 360     Int_t gLayer = 0, gLadder = 0, gModule = 0;
 361     //occupancy per SSD module
 362     TH1D *fHistSSDOccupancyModule[fgkSSDMODULES];
 363     for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
 364       AliITSgeomTGeo::GetModuleId(i,gLayer,gLadder,gModule);
 365       gTitle = "SSD/Occupancy/Layer"; gTitle += gLayer;
 366       gTitle += "/Ladder";
 367       if(gLayer == 5) {
 368         gTitle +=  499+gLadder;
 369         gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += gLayer;
 370         gTitle += "_Ladder";
 371         gTitle += 499+gLadder;
 372       }
 373       if(gLayer == 6) {
 374         gTitle += 599+gLadder;
 375         gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += gLayer;
 376         gTitle += "_Ladder";
 377         gTitle += 599+gLadder;
 378       }
 379       gTitle += "_Module"; gTitle += gModule;
 380       fHistSSDOccupancyModule[i-500] = new TH1D(gTitle.Data(),gTitle.Data(),
 381                                                 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
 382       fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1);
 383       fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}");
 384       fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]");
 385       fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500],
 386                                           fGenOffset+fSSDRawsOffset, kTRUE);
 387       fSSDRawsOffset += 1;
 388     }
 389
 390     //Occupancy per SSD ladder
 391     Int_t occupancyCounter = 0;
 392     TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
 393     for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
 394       for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
 395         //P-side occupancy plots
 396         gTitle = "SSD/Occupancy/Layer"; gTitle += iLayer;
 397         gTitle += "/Ladder";
 398         if(iLayer == 5) {
 399           gTitle += 499+iLadder;
 400           gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 401           gTitle += "_Ladder";
 402           gTitle += 499+iLadder;
 403         }
 404         if(iLayer == 6) {
 405           gTitle += 599+iLadder;
 406           gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 407           gTitle += "_Ladder";
 408           gTitle += 599+iLadder;
 409         }
 410         gTitle += "_PSide";
 411         fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
 412                                                              gTitle.Data(),
 413                                                              AliITSgeomTGeo::GetNDetectors(iLayer),
 414                                                              0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
 415         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
 416         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
 417         fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
 418         fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
 419                                             fGenOffset+fSSDRawsOffset, kTRUE);
 420         occupancyCounter += 1; fSSDRawsOffset += 1;
 421         //N-side occupancy plots
 422         gTitle = "SSD/Occupancy/Layer"; gTitle += iLayer;
 423         gTitle += "/Ladder";
 424         if(iLayer == 5) {
 425           gTitle += 499+iLadder;
 426           gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 427           gTitle += "_Ladder";
 428           gTitle += 499+iLadder;
 429         }
 430         if(iLayer == 6) {
 431           gTitle += 599+iLadder;
 432           gTitle += "/fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 433           gTitle += "_Ladder";
 434           gTitle += 599+iLadder;
 435         }
 436         gTitle += "_NSide";
 437         fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
 438                                                              gTitle.Data(),
 439                                                              AliITSgeomTGeo::GetNDetectors(iLayer),
 440                                                              0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
 441         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
 442         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
 443         fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
 444         fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
 445                                             fGenOffset+fSSDRawsOffset, kTRUE);
 446         occupancyCounter += 1; fSSDRawsOffset += 1;
 447       }//ladder loop
 448     }//layer loop
 449
 450     //top level occupancy plots
 451     //occupancy per module - no threshold
 452     TH2D *fHistSSDOccupancyLayer5 = new TH2D("SSD/Occupancy/Layer5/fHistSSDOccupancyLayer5",
 453                                              ";N_{modules};N_{Ladders}",
 454                                              fgkSSDMODULESPERLADDERLAYER5,
 455                                              0,fgkSSDMODULESPERLADDERLAYER5,
 456                                              3*fgkSSDLADDERSLAYER5,
 457                                              0,fgkSSDLADDERSLAYER5);
 458     fHistSSDOccupancyLayer5->SetTitle("Occupancy per module (Layer 5) - No threshold");
 459     Char_t fLabel[3];
 460     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 461       sprintf(fLabel,"%d",iBin);
 462       fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 463     }
 464     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5,
 465                                         fGenOffset+fSSDRawsOffset, kTRUE);
 466     fSSDRawsOffset += 1;
 467     TH2D *fHistSSDOccupancyLayer6 = new TH2D("SSD/Occupancy/Layer6/fHistSSDOccupancyLayer6",
 468                                              ";N_{modules};N_{Ladders}",
 469                                              fgkSSDMODULESPERLADDERLAYER6,
 470                                              0,fgkSSDMODULESPERLADDERLAYER6,
 471                                              3*fgkSSDLADDERSLAYER6,
 472                                              0,fgkSSDLADDERSLAYER6);
 473     fHistSSDOccupancyLayer6->SetTitle("Occupancy per module (Layer 6) - No threshold");
 474     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 475       sprintf(fLabel,"%d",iBin);
 476       fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 477     }
 478     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6,
 479                                         fGenOffset+fSSDRawsOffset, kTRUE);
 480     fSSDRawsOffset += 1;
 481
 482     //occupancy per module - threshold @ 3%
 483     TH2D *fHistSSDOccupancyThresholdLayer5 = new TH2D("SSD/Occupancy/Layer5/fHistSSDOccupancyThresholdLayer5",
 484                                              ";N_{modules};N_{Ladders}",
 485                                              fgkSSDMODULESPERLADDERLAYER5,
 486                                              0,fgkSSDMODULESPERLADDERLAYER5,
 487                                              3*fgkSSDLADDERSLAYER5,
 488                                              0,fgkSSDLADDERSLAYER5);
 489     fHistSSDOccupancyThresholdLayer5->SetTitle("Occupancy per module (Layer 5) - Threshold 3%");
 490     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 491       sprintf(fLabel,"%d",iBin);
 492       fHistSSDOccupancyThresholdLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 493      }
 494      fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5,
 495                                          fGenOffset+fSSDRawsOffset, kTRUE);
 496     fSSDRawsOffset += 1;
 497     TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("SSD/Occupancy/Layer6/fHistSSDOccupancyThresholdLayer6",
 498                                              ";N_{modules};N_{Ladders}",
 499                                              fgkSSDMODULESPERLADDERLAYER6,
 500                                              0,fgkSSDMODULESPERLADDERLAYER6,
 501                                              3*fgkSSDLADDERSLAYER6,
 502                                              0,fgkSSDLADDERSLAYER6);
 503     fHistSSDOccupancyThresholdLayer6->SetTitle("Occupancy per module (Layer 6) - Threshold 3%");
 504     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 505       sprintf(fLabel,"%d",iBin);
 506       fHistSSDOccupancyThresholdLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 507     }
 508     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6,
 509                                         fGenOffset+fSSDRawsOffset, kTRUE);
 510     fSSDRawsOffset += 1;
 511
 512     //Average occupancy per module
 513     TH2D *fHistSSDAverageOccupancyLayer5 = new TH2D("SSD/Occupancy/Layer5/fHistSSDAverageOccupancyLayer5",
 514                                              ";N_{modules};N_{Ladders}",
 515                                              fgkSSDMODULESPERLADDERLAYER5,
 516                                              0,fgkSSDMODULESPERLADDERLAYER5,
 517                                              3*fgkSSDLADDERSLAYER5,
 518                                              0,fgkSSDLADDERSLAYER5);
 519     fHistSSDAverageOccupancyLayer5->SetTitle("Average occupancy per module (Layer 5)");
 520     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 521       sprintf(fLabel,"%d",iBin);
 522       fHistSSDAverageOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 523     }
 524     fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer5,
 525                                         fGenOffset+fSSDRawsOffset);
 526     fSSDRawsOffset += 1;
 527     TH2D *fHistSSDAverageOccupancyLayer6 = new TH2D("SSD/Occupancy/Layer6/fHistSSDAverageOccupancyLayer6",
 528                                              ";N_{modules};N_{Ladders}",
 529                                              fgkSSDMODULESPERLADDERLAYER6,
 530                                              0,fgkSSDMODULESPERLADDERLAYER6,
 531                                              3*fgkSSDLADDERSLAYER6,
 532                                              0,fgkSSDLADDERSLAYER6);
 533     fHistSSDAverageOccupancyLayer6->SetTitle("Average occupancy per module (Layer 6)");
 534     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 535       sprintf(fLabel,"%d",iBin);
 536       fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 537     }
 538     fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6,
 539                                         fGenOffset+fSSDRawsOffset);
 540     fSSDRawsOffset += 1;
 541
 542     //Output of the DA
 543     TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("SSD/BadChannels/fHistPSideBadChannelMapLayer5",
 544                                                    "Layer 5;N_{module};N_{ladder}",
 545                                                    22,1,23,
 546                                                    34,500,534);
 547     fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
 548     fHistPSideBadChannelMapLayer5->SetStats(kFALSE);
 549     fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 550     fHistPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);
 551     fHistPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);
 552     fHistPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);
 553     fHistPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);
 554     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 555     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
 556     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5,
 557                                         fGenOffset+fSSDRawsOffset, kTRUE);
 558     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 559
 560     TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("SSD/BadChannels/fHistNSideBadChannelMapLayer5",
 561                                                    "Layer 5;N_{module};N_{ladder}",
 562                                                    22,1,23,
 563                                                    34,500,534);
 564     fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
 565     fHistNSideBadChannelMapLayer5->SetStats(kFALSE);
 566     fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 567     fHistNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);
 568     fHistNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);
 569     fHistNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);
 570     fHistNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);
 571     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 572     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
 573     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5,
 574                                         fGenOffset+fSSDRawsOffset, kTRUE);
 575     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 576
 577     TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("SSD/BadChannels/fHistPSideBadChannelMapLayer6",
 578                                                    "Layer 6;N_{module};N_{ladder}",
 579                                                    25,1,26,
 580                                                    38,600,638);
 581     fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
 582     fHistPSideBadChannelMapLayer6->SetStats(kFALSE);
 583     fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 584     fHistPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);
 585     fHistPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);
 586     fHistPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);
 587     fHistPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);
 588     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 589     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
 590     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6,
 591                                         fGenOffset+fSSDRawsOffset, kTRUE);
 592     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 593
 594     TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("SSD/BadChannels/fHistNSideBadChannelMapLayer6",
 595                                                    "Layer 6;N_{module};N_{ladder}",
 596                                                    25,1,26,
 597                                                    38,600,638);
 598     fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
 599     fHistNSideBadChannelMapLayer6->SetStats(kFALSE);
 600     fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 601     fHistNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);
 602     fHistNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);
 603     fHistNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);
 604     fHistNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);
 605     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 606     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
 607     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6,
 608                                         fGenOffset+fSSDRawsOffset, kTRUE);
 609     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 610   }//online flag
 611   fSSDhTask = fSSDRawsOffset;
 612   AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask));
 613   AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDhTask));
 614   AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDRawsOffset));
 615 }
 616
 617 //____________________________________________________________________________
 618 void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) {
 619   // Fill QA for RAW - SSD -
 620   Int_t gStripNumber;
 621   Int_t gHistPosition;
 622   Int_t gLayer = 0,gLadder = 0, gModule = 0;
 623
 624   Double_t gSizePerDDL[fgkNumOfDDLs] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
 625   Double_t gSizePerLDC[fgkNumOfLDCs] = {0.,0.,0.};
 626   Double_t sumSSDDataSize = 0.0;
 627   Double_t eventSize = -1.0;
 628
 629   if(fkOnline) {
 630     //reset the signal vs strip number histograms
 631     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
 632       fHistSSDRawSignalModule[iModule]->Reset();
 633   }//online flag
 634
 635   rawReader->Select("ITSSSD",-1,-1);
 636   rawReader->Reset(); //rawReader->NextEvent();
 637   (fAliITSQADataMakerRec->GetRawsData(fGenOffset))->Fill(rawReader->GetType());
 638   if(rawReader->GetType() == 7) {
 639     fSSDEvent += 1;
 640     fSSDEventPerCycle += 1;
 641   }
 642
 643   AliITSRawStreamSSD gSSDStream(rawReader);
 644   AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
 645   if(rootReader) {
 646     const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
 647     if(header)
 648       eventSize = header->GetEventSize();
 649   }
 650   while (gSSDStream.Next()) {
 651     if(gSSDStream.GetModuleID() < 0) continue;
 652     /*cout<<"DDL: "<<rawReader->GetDDLID()<<
 653       " - LDC: "<<rawReader->GetLDCId()<<
 654       " - Size: "<<rawReader->GetDataSize()<<
 655       " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/
 656     gSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize();
 657     gSizePerLDC[rawReader->GetLDCId()-6] = rawReader->GetDataSize();
 658     AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 659     if(gSSDStream.GetStrip() < 0) continue;
 660     gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
 661     gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
 662     //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
 663     if(fkOnline)
 664       fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
 665     //fAliITSQADataMakerRec->GetRawsData(fGenOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());
 666   }//streamer loop
 667
 668   //event size calculation and filling info
 669   for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
 670     sumSSDDataSize += gSizePerDDL[i];
 671     if(gSizePerDDL[i] > 0) {
 672       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+3))->Fill(i+512);
 673       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->Fill(TMath::Log10(gSizePerDDL[i]));
 674     }
 675     //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4))->Fill(i+512,gSizePerDDL[i]/1e+06);
 676   }
 677   for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
 678     if(gSizePerLDC[i] > 0) {
 679       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+21))->Fill(i+6);
 680       //LDC 082
 681       if(i == 0)
 682         gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9] + gSizePerDDL[10] +
 683           gSizePerDDL[11] + gSizePerDDL[12] + gSizePerDDL[13];
 684       //LDC 086
 685       if(i == 1)
 686         gSizePerLDC[i] = gSizePerDDL[3] + gSizePerDDL[4] + gSizePerDDL[5] +
 687           gSizePerDDL[6] + gSizePerDDL[7];
 688       //LDC 085
 689       if(i == 2)
 690         gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1] + gSizePerDDL[2] +
 691           gSizePerDDL[14] + gSizePerDDL[15];
 692       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->Fill(TMath::Log10(gSizePerLDC[i]));
 693       //cout<<"Event: "<<fSSDEventPerCycle<<" - LDC: "<<i+6<<
 694       //" - Data size: "<<gSizePerLDC[i]<<endl;
 695     }
 696     //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22))->Fill(i+6,gSizePerLDC[i]/1e+06);
 697   }
 698   if(sumSSDDataSize)
 699     (fAliITSQADataMakerRec->GetRawsData(fGenOffset+1))->Fill(TMath::Log10(sumSSDDataSize));
 700   if(eventSize)
 701     (fAliITSQADataMakerRec->GetRawsData(fGenOffset+2))->Fill(100.*sumSSDDataSize/eventSize);
 702
 703   //Occupancy calculation
 704   if(fkOnline) {
 705     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 706       GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]);
 707       //if(iModule == 156) {
 708         //cout<<"========================================"<<endl;
 709         //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule);
 710         /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) {
 711           if((iBin >= 750)&&(iBin <= 780))
 712           cout<<"Event: "<<fSSDEventPerCycle<<" - Ladder: "<<gLadder+499<<
 713           " - Module: "<<gModule<<" - Strip: "<<iBin<<
 714           " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl;
 715           }*///strip loop --> to be removed
 716       //}//module cut --> to be removed
 717     }//module loop
 718   }//online flag for SSD
 719 }
 720
 721 //____________________________________________________________________________ //
 722 void AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) {
 723   //Increments the entries in the occupancy matrix based
 724   //on whether the signal for each strip is larger than the cutoff
 725   //Currently the cutoff is at 0 which means that if ZS
 726   //works, whatever comes from the FEROM is considered as "signal"
 727   //Double_t cutoff = 0.0;
 728   TString histname = lHisto->GetName();
 729   //cout<<histname.Data()<<endl;
 730   //if(histname.Contains("Layer5_Ladder8_Module3")) {
 731   for(Int_t iBin = 1; iBin < lHisto->GetXaxis()->GetNbins(); iBin++) {
 732     Double_t y = lHisto->GetBinContent(iBin);
 733     if(y) {
 734       occupancyMatrix[iBin-1] += 1;
 735     }
 736     //if((iBin >= 750)&&(iBin <= 780))
 737     //cout<<"Strip: "<<iBin<<
 738     //" - Signal: "<<y<<
 739     //" - Occupancy: "<<occupancyMatrix[iBin-1]<<endl;
 740
 741   }
 742   //}
 743 }
 744
 745 //____________________________________________________________________________
 746 Double_t AliITSQASSDDataMakerRec::GetOccupancyModule(TH1 *lHisto,
 747                                                      Int_t stripside,
 748                                                      Int_t mode,
 749                                                      Double_t threshold) {
 750   //Mode 0: calculates the occupancy of a module
 751   //        without a threshold in the strip occupancy
 752   //Mode 1: calculates the occupancy of a module
 753   //        with the set threshold in the strip occupancy
 754   //Mode 2: calculates the average occupancy of a module
 755
 756   // bo: TDC >0 or # of sigmas wrt noise ?
 757   //stripside == 0 --> P-side
 758   //stripside == 1 --> N-side
 759   Int_t lNumFiredBins = 0;
 760   Double_t sumOccupancy = 0.0;
 761   TString histname = lHisto->GetName();
 762   for(Int_t iBin = 1 + stripside*fgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips*(1 + stripside); iBin++){
 763     /*if(histname.Contains("Layer5_Ladder507_Module3")) {
 764       cout<<lHisto->GetName()<<
 765       " - Strip: "<<iBin<<
 766       " - Bin content: "<<lHisto->GetBinContent(iBin)<<endl;
 767       }*/
 768     if (lHisto->GetBinContent(iBin) > threshold) {
 769       lNumFiredBins++;
 770       sumOccupancy = lHisto->GetBinContent(iBin);
 771     }
 772   }
 773
 774   Double_t lOccupancy = 0.0;
 775   if((mode == 0)||(mode == 1))
 776     lOccupancy = (100.*lNumFiredBins)/fgkNumberOfPSideStrips; // percentage
 777   else if(mode == 2)
 778     lOccupancy = 100.*sumOccupancy/fgkNumberOfPSideStrips;
 779
 780   /*if(histname.Contains("Layer5_Ladder507_Module3"))
 781     cout<<"Fired strips: "<<lNumFiredBins<<
 782     " - Occupancy: "<<lOccupancy<<endl;*/
 783   //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
 784
 785   return lOccupancy;
 786 }
 787
 788 //____________________________________________________________________________
 789 void AliITSQASSDDataMakerRec::MonitorOCDBObjects() {
 790   //Monitor in AMORE the output of the DA
 791   //Currently only the bad channel list is monitored
 792   //Todo: Noise - Pedestal
 793   ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Reset();
 794   ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Reset();
 795   ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Reset();
 796   ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Reset();
 797
 798   AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD");
 799   if(!entryBadChannelsSSD)
 800     AliError("OCDB entry for the bad channel list is not valid!");
 801   AliITSBadChannelsSSDv2 *badchannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject();
 802   if(!badchannelsSSD)
 803     AliError("Bad channel list object is not a valid AliITSBadChannelsSSD object!");
 804
 805   //_____________________________________________________________________________//
 806   Int_t nBadPSideChannels = 0, nBadNSideChannels = 0;
 807   Int_t layer = 0, ladder = 0, module = 0;
 808   Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;
 809   Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;
 810   //_____________________________________________________________________________//
 811
 812   for(Int_t i = 0; i < fgkSSDMODULES; i++) {
 813     AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module);
 814     nBadPSideChannels = 0, nBadNSideChannels = 0;
 815     nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;
 816     nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;
 817
 818     Int_t badChannel = 0;
 819     for(Int_t j = 0; j < fgkNumberOfPSideStrips; j++) {
 820       badChannel = (Int_t)(badchannelsSSD->GetBadChannelP(i,j));
 821       if(badChannel != 0) {
 822         if(layer == 5)
 823           nPSideChannelsLayer5 += 1;
 824         if(layer == 6)
 825           nPSideChannelsLayer6 += 1;
 826         nBadPSideChannels += 1;
 827       }//badchannel flag != 0
 828       badChannel = (Int_t)(badchannelsSSD->GetBadChannelN(i,j));
 829       if(badChannel != 0) {
 830         if(layer == 5)
 831           nNSideChannelsLayer5 += 1;
 832         if(layer == 6)
 833           nNSideChannelsLayer6 += 1;
 834         nBadNSideChannels += 1;
 835       }//badchannel flag != 0
 836     }//loop over strips
 837     if(layer == 5) {
 838       if(nPSideChannelsLayer5 > 0)
 839         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,
 840                                                                             100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips);
 841       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,0.0001);
 842       if(nNSideChannelsLayer5 > 0)
 843         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,
 844                                                                             100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips);
 845       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,0.0001);
 846     }//layer 5
 847     if(layer == 6) {
 848       if(nPSideChannelsLayer6 > 0)
 849         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,
 850                                                                             100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips);
 851       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,0.0001);
 852       if(nNSideChannelsLayer6 > 0)
 853         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,
 854                                                                             100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips);
 855       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,0.0001);
 856     }//layer 6
 857   }//module loop
 858 }
 859
 860 //____________________________________________________________________________
 861 void AliITSQASSDDataMakerRec::InitRecPoints()
 862 {
 863   // Initialization for RECPOINTS - SSD -
 864
 865   fGenOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();
 866   Int_t nModuleOffset = 500;
 867   Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
 868
 869   TH1F *fHistSSDModuleIdLayer5 = new TH1F("SSD/Statistics/fHistSSDModuleIdLayer5",
 870                                        "Module Id - Layer 5;Module Id;Entries",
 871                                        fgkSSDMODULESLAYER5,
 872                                        nModuleOffset - 0.5,
 873                                        nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
 874   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer5,
 875                                            fGenOffset + 0, kTRUE);
 876   fSSDhTask += 1;
 877   TH1F *fHistSSDModuleIdLayer6 = new TH1F("SSD/Statistics/fHistSSDModuleIdLayer6",
 878                                        "Module Id - Layer 6;Module Id;Entries",
 879                                        fgkSSDMODULESLAYER6,
 880                                        nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
 881                                        nITSTotalModules + 0.5);
 882   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer6,
 883                                            fGenOffset + 1, kTRUE);
 884   fSSDhTask += 1;
 885   TH1F *fHistSSDClusterPerEventLayer5 = new TH1F("SSD/Statistics/fHistSSDClusterPerEventLayer5",
 886                                               "N_{clusters} - Layer 5;N_{clusters};Entries;",
 887                                               100,0.1,5000);
 888   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer5,
 889                                            fGenOffset + 2, kTRUE);
 890   fSSDhTask += 1;
 891   TH1F *fHistSSDClusterPerEventLayer6 = new TH1F("SSD/Statistics/fHistSSDClusterPerEventLayer6",
 892                                               "N_{clusters} - Layer 6;N_{clusters};Entries;",
 893                                               100,0.1,5000);
 894   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer6,
 895                                            fGenOffset + 3, kTRUE);
 896   fSSDhTask += 1;
 897   TH1F *fHistSSDLocalXLayer5 = new TH1F("SSD/Coordinates/fHistSSDLocalXLayer5",
 898                                      "Local x coord.- Layer 5;x [cm];Entries;",
 899                                      100,-4.,4.);
 900   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer5,
 901                                            fGenOffset + 4, kTRUE);
 902   fSSDhTask += 1;
 903   TH1F *fHistSSDLocalXLayer6 = new TH1F("SSD/Coordinates/fHistSSDLocalXLayer6",
 904                                      "Local x coord.- Layer 6;x [cm];Entries;",
 905                                      100,-4.,4.);
 906   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer6,
 907                                            fGenOffset + 5, kTRUE);
 908   fSSDhTask += 1;
 909   TH1F *fHistSSDLocalZLayer5 = new TH1F("SSD/Coordinates/fHistSSDLocalZLayer5",
 910                                      "Local z coord.- Layer 5;z [cm];Entries;",
 911                                      100,-4.,4.);
 912   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer5,
 913                                            fGenOffset + 6, kTRUE);
 914   fSSDhTask += 1;
 915   TH1F *fHistSSDLocalZLayer6 = new TH1F("SSD/Coordinates/fHistSSDLocalZLayer6",
 916                                      "Local z coord.- Layer 6;z [cm];Entries;",
 917                                      100,-4.,4.);
 918   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer6,
 919                                            fGenOffset + 7, kTRUE);
 920   fSSDhTask += 1;
 921   TH1F *fHistSSDGlobalXLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalXLayer5",
 922                                       "Global x - Layer 5;x [cm];Entries;",
 923                                       100,-40.,40.);
 924   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer5,
 925                                            fGenOffset + 8, kTRUE);
 926   fSSDhTask += 1;
 927   TH1F *fHistSSDGlobalXLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalXLayer6",
 928                                       "Global x - Layer 6;x [cm];Entries;",
 929                                       100,-45.,45.);
 930   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer6,
 931                                            fGenOffset + 9, kTRUE);
 932   fSSDhTask += 1;
 933   TH1F *fHistSSDGlobalYLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalYLayer5",
 934                                       "Global y - Layer 5;y [cm];Entries;",
 935                                       100,-40.,40);
 936   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer5,
 937                                            fGenOffset + 10, kTRUE);
 938   fSSDhTask += 1;
 939   TH1F *fHistSSDGlobalYLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalYLayer6",
 940                                       "Global y - Layer 6;y [cm];Entries;",
 941                                       100,-45.,45.);
 942   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer6,
 943                                            fGenOffset + 11, kTRUE);
 944   fSSDhTask += 1;
 945   TH1F *fHistSSDGlobalZLayer5 = new TH1F("SSD/Coordinates/fHistSSDGlobalZLayer5",
 946                                       "Global z - Layer 5;z [cm];Entries;",
 947                                       100,-45.,45);
 948   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer5,
 949                                            fGenOffset + 12, kTRUE);
 950   fSSDhTask += 1;
 951   TH1F *fHistSSDGlobalZLayer6 = new TH1F("SSD/Coordinates/fHistSSDGlobalZLayer6",
 952                                       "Global z - Layer 6;z [cm];Entries;",
 953                                       100,-55.,55.);
 954   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer6,
 955                                            fGenOffset + 13, kTRUE);
 956   fSSDhTask += 1;
 957   TH1F *fHistSSDPhiLayer5 = new TH1F("SSD/Coordinates/fHistSSDPhiLayer5",
 958                                   "#phi - Layer 5;#phi [rad];Entries;",
 959                                   100,-TMath::Pi(),TMath::Pi());
 960   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer5,
 961                                            fGenOffset + 14, kTRUE);
 962   fSSDhTask += 1;
 963   TH1F *fHistSSDPhiLayer6 = new TH1F("SSD/Coordinates/fHistSSDPhiLayer6",
 964                                   "#phi - Layer 6;#phi [rad];Entries;",
 965                                   100,-TMath::Pi(),TMath::Pi());
 966   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer6,
 967                                            fGenOffset + 15, kTRUE);
 968   fSSDhTask += 1;
 969   TH1F *fHistSSDThetaLayer5 = new TH1F("SSD/Coordinates/fHistSSDThetaLayer5",
 970                                     "#theta - Layer 5;#theta [rad];Entries;",
 971                                     100,-TMath::Pi(),TMath::Pi());
 972   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer5,
 973                                            fGenOffset + 16, kTRUE);
 974   fSSDhTask += 1;
 975   TH1F *fHistSSDThetaLayer6 = new TH1F("SSD/Coordinates/fHistSSDThetaLayer6",
 976                                     "#theta - Layer 6;#theta [rad];Entries;",
 977                                     100,-TMath::Pi(),TMath::Pi());
 978   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer6,
 979                                            fGenOffset + 17, kTRUE);
 980   fSSDhTask += 1;
 981   TH1F *fHistSSDRadiusLayer5 = new TH1F("SSD/Coordinates/fHistSSDRadiusLayer5",
 982                                      "r - Layer 5;r [cm];Entries;",
 983                                      100,35.,50.);
 984   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer5,
 985                                            fGenOffset + 18, kTRUE);
 986   fSSDhTask += 1;
 987   TH1F *fHistSSDRadiusLayer6 = new TH1F("SSD/Coordinates/fHistSSDRadiusLayer6",
 988                                      "r - Layer 6;r [cm];Entries;",
 989                                      100,35.,50.);
 990   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer6,
 991                                            fGenOffset + 19, kTRUE);
 992   fSSDhTask += 1;
 993   TH1F *fHistSSDClusterTypeLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDClusterTypeLayer5",
 994                                           "CL type - Layer 5;Cluster type;Entries;",
 995                                           150,0,150);
 996   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer5,
 997                                            fGenOffset + 20, kTRUE);
 998   fSSDhTask += 1;
 999   TH1F *fHistSSDClusterTypeLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDClusterTypeLayer6",
1000                                           "CL type - Layer 6;Cluster type;Entries;",
1001                                           150,0,150);
1002   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer6,
1003                                            fGenOffset + 21, kTRUE);
1004   fSSDhTask += 1;
1005   TH1F *fHistSSDChargeRatioLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeRatioLayer5",
1006                                           "Charge ratio - Layer 5;q_{ratio};Entries;",
1007                                           100,-2.0,2.0);
1008   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer5,
1009                                            fGenOffset + 22, kTRUE);
1010   fSSDhTask += 1;
1011   TH1F *fHistSSDChargeRatioLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeRatioLayer6",
1012                                           "Charge ratio - Layer 6;q_{ratio};Entries;",
1013                                           100,-2.0,2.0);
1014   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer6,
1015                                            fGenOffset + 23, kTRUE);
1016   fSSDhTask += 1;
1017   TH1F *fHistSSDChargekeVLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargekeVLayer5",
1018                                         "Charge - Layer 5;q [keV];Entries;",
1019                                         100,0.,300.);
1020   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer5,
1021                                            fGenOffset + 24);
1022   fSSDhTask += 1;
1023   TH1F *fHistSSDChargekeVLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargekeVLayer6",
1024                                         "Charge - Layer 6;q [keV];Entries;",
1025                                         100,0.,300.);
1026   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer6,
1027                                            fGenOffset + 25);
1028   fSSDhTask += 1;
1029   TH1F *fHistSSDChargePSideLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargePSideLayer5",
1030                                           "Charge P- Layer 5;q_{P} [keV];Entries;",
1031                                           100,0.,300.);
1032   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer5,
1033                                            fGenOffset + 26, kTRUE);
1034   fSSDhTask += 1;
1035   TH1F *fHistSSDChargePSideLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargePSideLayer6",
1036                                           "Charge P- Layer 6;q_{P} [keV];Entries;",
1037                                           100,0.,300.);
1038   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer6,
1039                                            fGenOffset + 27, kTRUE);
1040   fSSDhTask += 1;
1041   TH1F *fHistSSDChargeNSideLayer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeNSideLayer5",
1042                                           "Charge N- Layer 5;q_{N} [keV];Entries;",
1043                                           100,0.,300.);
1044   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer5,
1045                                            fGenOffset + 28, kTRUE);
1046   fSSDhTask += 1;
1047   TH1F *fHistSSDChargeNSideLayer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeNSideLayer6",
1048                                           "Charge N- Layer 6;q_{N} [keV];Entries;",
1049                                           100,0.,300.);
1050   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer6,
1051                                            fGenOffset + 29, kTRUE);
1052   fSSDhTask += 1;
1053   TH1F *fHistSSDChargeRatio2Layer5 = new TH1F("SSD/ClusterCharge/Layer5/fHistSSDChargeRatio2Layer5",
1054                                           "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
1055                                           100,0,2);
1056   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer5,
1057                                            fGenOffset + 30, kTRUE);
1058   fSSDhTask += 1;
1059   TH1F *fHistSSDChargeRatio2Layer6 = new TH1F("SSD/ClusterCharge/Layer6/fHistSSDChargeRatio2Layer6",
1060                                            "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
1061                                            100,0,2);
1062   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer6,
1063                                            fGenOffset + 31, kTRUE);
1064   fSSDhTask += 1;
1065   TH2F *fHistSSDChargePNSideLayer5 = new TH2F("SSD/ClusterCharge/Layer5/fHistSSDChargePNSideLayer5",
1066                                            "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
1067                                            100,0.,300.,
1068                                            100,0.,300.);
1069   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer5,
1070                                            fGenOffset + 32, kTRUE);
1071   fSSDhTask += 1;
1072   TH2F *fHistSSDChargePNSideLayer6 = new TH2F("SSD/ClusterCharge/Layer6/fHistSSDChargePNSideLayer6",
1073                                            "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
1074                                            100,0.,300.,
1075                                            100,0.,300.);
1076   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer6,
1077                                            fGenOffset + 33, kTRUE);
1078   fSSDhTask += 1;
1079   TH2F *fHistSSDChargeMapLayer5 = new TH2F("SSD/ClusterCharge/Layer5/fHistSSDChargeMapLayer5",
1080                                         "Charge map;N_{modules};N_{Ladders}",
1081                                         fgkSSDMODULESPERLADDERLAYER5,
1082                                         -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,
1083                                         3*fgkSSDLADDERSLAYER5,
1084                                         -0.5,fgkSSDLADDERSLAYER5+0.5);
1085   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer5,
1086                                            fGenOffset + 34, kTRUE);
1087   fSSDhTask += 1;
1088   TH2F *fHistSSDChargeMapLayer6 = new TH2F("SSD/ClusterCharge/Layer6/fHistSSDChargeMapLayer6",
1089                                         "Charge map;N_{modules};N_{Ladders}",
1090                                         fgkSSDMODULESPERLADDERLAYER6,
1091                                         -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,
1092                                         3*fgkSSDLADDERSLAYER6,
1093                                         -0.5,fgkSSDLADDERSLAYER6+0.5);
1094   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer6,
1095                                            fGenOffset + 35, kTRUE);
1096   fSSDhTask += 1;
1097   TH2F *fHistSSDClusterMapLayer5 = new TH2F("SSD/Statistics/Layer5/fHistSSDClusterMapLayer5",
1098                                          "Layer 5;N_{module};N_{ladder}",
1099                                          22,1,23,
1100                                          34,500,534);
1101   fHistSSDClusterMapLayer5->GetXaxis()->SetTitleColor(1);
1102   fHistSSDClusterMapLayer5->SetStats(kFALSE);
1103   fHistSSDClusterMapLayer5->GetYaxis()->SetTitleOffset(1.8);
1104   fHistSSDClusterMapLayer5->GetXaxis()->SetNdivisions(22);
1105   fHistSSDClusterMapLayer5->GetYaxis()->SetNdivisions(34);
1106   fHistSSDClusterMapLayer5->GetXaxis()->SetLabelSize(0.03);
1107   fHistSSDClusterMapLayer5->GetYaxis()->SetLabelSize(0.03);
1108   fHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
1109   fHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
1110   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer5,
1111                                            fGenOffset + 36);
1112   fSSDhTask += 1;
1113   TH2F *fHistSSDClusterMapLayer6 = new TH2F("SSD/Statistics/Layer6/fHistSSDClusterMapLayer6",
1114                                          "Layer 6;N_{module};N_{ladder}",
1115                                          25,1,26,
1116                                          38,600,638);
1117   fHistSSDClusterMapLayer6->GetXaxis()->SetTitleColor(1);
1118   fHistSSDClusterMapLayer6->SetStats(kFALSE);
1119   fHistSSDClusterMapLayer6->GetYaxis()->SetTitleOffset(1.8);
1120   fHistSSDClusterMapLayer6->GetXaxis()->SetNdivisions(25);
1121   fHistSSDClusterMapLayer6->GetYaxis()->SetNdivisions(38);
1122   fHistSSDClusterMapLayer6->GetXaxis()->SetLabelSize(0.03);
1123   fHistSSDClusterMapLayer6->GetYaxis()->SetLabelSize(0.03);
1124   fHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
1125   fHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
1126   fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer6,
1127                                            fGenOffset + 37);
1128   fSSDhTask += 1;
1129
1130   AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhTask));
1131 }
1132
1133 //____________________________________________________________________________
1134 void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree)
1135 {
1136   // Fill QA for recpoints - SSD -
1137
1138   Int_t gLayer = 0, gLadder = 0, gModule = 0;
1139   Int_t lLadderLocationY = 0;
1140   TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints");
1141   if (!branchRecP) {
1142     AliError("can't get the branch with the ITS clusters !");
1143     return;
1144   }
1145   static TClonesArray statRecpoints("AliITSRecPoint");
1146   TClonesArray *recpoints = &statRecpoints;
1147   branchRecP->SetAddress(&recpoints);
1148   Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;
1149   Int_t npoints = 0;
1150   Float_t cluglo[3]={0.,0.,0.};
1151   for(Int_t module = 0; module < clustersTree->GetEntries(); module++){
1152     branchRecP->GetEvent(module);
1153     npoints += recpoints->GetEntries();
1154     AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);
1155     lLadderLocationY = 3*gLadder;
1156
1157     for(Int_t j = 0;j < recpoints->GetEntries(); j++){
1158       AliITSRecPoint *recp = (AliITSRecPoint*)recpoints->At(j);
1159       Int_t layer = recp->GetLayer();
1160       recp->GetGlobalXYZ(cluglo);
1161       Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]);
1162       Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);
1163       Float_t theta = TMath::ATan2(radius,cluglo[2]);
1164       Double_t chargeRatio = recp->GetChargeRatio();
1165       Double_t clusterCharge = recp->GetQ();
1166       Double_t chargePSide = clusterCharge*(1. + chargeRatio);
1167       Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
1168       if(layer == 4) {
1169         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 0)->Fill(module);
1170         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 4)->Fill(recp->GetDetLocalX());
1171         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 6)->Fill(recp->GetDetLocalZ());
1172         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 8)->Fill(cluglo[0]);
1173         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 10)->Fill(cluglo[1]);
1174         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 12)->Fill(cluglo[2]);
1175         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 14)->Fill(phi);
1176         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 16)->Fill(theta);
1177         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 18)->Fill(radius);
1178         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 20)->Fill(recp->GetType());
1179         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 22)->Fill(recp->GetChargeRatio());
1180         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 24)->Fill(recp->GetQ());
1181         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 26)->Fill(chargePSide);
1182         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 28)->Fill(chargeNSide);
1183         if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 30)->Fill(chargeNSide/chargePSide);
1184         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 32)->Fill(chargePSide,chargeNSide);
1185         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 34)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
1186         ((TH2F *)fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 36))->Fill(gModule,499+gLadder,1);
1187         nClustersLayer5 += 1;
1188       }//layer 5 histograms
1189       if(layer == 5) {
1190         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 1)->Fill(module);
1191         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 5)->Fill(recp->GetDetLocalX());
1192         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 7)->Fill(recp->GetDetLocalZ());
1193         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 9)->Fill(cluglo[0]);
1194         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 11)->Fill(cluglo[1]);
1195         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 13)->Fill(cluglo[2]);
1196         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 15)->Fill(phi);
1197         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 17)->Fill(theta);
1198         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 19)->Fill(radius);
1199         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 21)->Fill(recp->GetType());
1200         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 23)->Fill(recp->GetChargeRatio());
1201         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 25)->Fill(recp->GetQ());
1202         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 27)->Fill(chargePSide);
1203         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 29)->Fill(chargeNSide);
1204         if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 31)->Fill(chargeNSide/chargePSide);
1205         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 33)->Fill(chargePSide,chargeNSide);
1206         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 35)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
1207         ((TH2F *)fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 37))->Fill(gModule,599+gLadder,1);
1208         nClustersLayer6 += 1;
1209       }//layer 6 histograms
1210     }//rec. points loop
1211   }//module loop
1212
1213   fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 2)->Fill(nClustersLayer5);
1214   fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 3)->Fill(nClustersLayer6);
1215
1216   statRecpoints.Clear();
1217 }
1218