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("fHistSSDEventType",
 295                                      ";Event type;Events",
 296                                      31,-1,30);
 297   fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType,
 298                                       fGenOffset+fSSDRawsOffset);
 299   fSSDRawsOffset += 1;
 300   TH1F *fHistSSDDataSize = new TH1F("fHistSSDDataSize",
 301                                     ";log(SSD data size) [Bytes];Events",
 302                                     100,3,8);
 303   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize,
 304                                       fGenOffset+fSSDRawsOffset);
 305   fSSDRawsOffset += 1;
 306   TH1F *fHistSSDDataSizePercentage = new TH1F("fHistSSDDataSizePercentage",
 307                                               ";SSD data size [%];Events",
 308                                               100,0,100);
 309   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage,
 310                                       fGenOffset+fSSDRawsOffset);
 311   fSSDRawsOffset += 1;
 312   TH1F *fHistSSDDDLId = new TH1F("fHistSSDDDLId",
 313                                  ";DDL id;Events",20,510.5,530.5);
 314   fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId,
 315                                       fGenOffset+fSSDRawsOffset);
 316   fSSDRawsOffset += 1;
 317   TH1F *fHistSSDDataSizePerDDL = new TH1F("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 = "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);
 331     fSSDRawsOffset += 1;
 332   }
 333
 334   TH1F *fHistSSDLDCId = new TH1F("fHistSSDLDCId",";LDC id;Events",10,0.5,10.5);
 335   fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId,
 336                                       fGenOffset+fSSDRawsOffset);
 337   fSSDRawsOffset += 1;
 338   TH1F *fHistSSDDataSizePerLDC = new TH1F("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 = "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);
 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 = "fHistSSD_Occupancy_Layer"; gTitle += gLayer;
 366       gTitle += "_Ladder";
 367       if(gLayer == 5)
 368         gTitle += 499+gLadder;
 369       if(gLayer == 6)
 370         gTitle += 599+gLadder;
 371       gTitle += "_Module"; gTitle += gModule;
 372       fHistSSDOccupancyModule[i-500] = new TH1D(gTitle.Data(),gTitle.Data(),
 373                                                 2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
 374       fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1);
 375       fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitle("N_{strip}");
 376       fHistSSDOccupancyModule[i-500]->GetYaxis()->SetTitle("Occupancy [%]");
 377       fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500], fGenOffset+fSSDRawsOffset);
 378       fSSDRawsOffset += 1;
 379     }
 380
 381     //Occupancy per SSD ladder
 382     Int_t occupancyCounter = 0;
 383     TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
 384     for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
 385       for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
 386         //P-side occupancy plots
 387         gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 388         gTitle += "_Ladder";
 389         if(iLayer == 5)
 390           gTitle += 499+iLadder;
 391         if(iLayer == 6)
 392           gTitle += 599+iLadder;
 393         gTitle += "_PSide";
 394         fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
 395                                                              gTitle.Data(),
 396                                                              AliITSgeomTGeo::GetNDetectors(iLayer),
 397                                                              0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
 398         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
 399         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
 400         fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
 401         fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
 402                                             fGenOffset+fSSDRawsOffset);
 403         occupancyCounter += 1; fSSDRawsOffset += 1;
 404         //N-side occupancy plots
 405         gTitle = "fHistSSD_Occupancy_Layer"; gTitle += iLayer;
 406         gTitle += "_Ladder";
 407         if(iLayer == 5)
 408           gTitle += 499+iLadder;
 409         if(iLayer == 6)
 410           gTitle += 599+iLadder;
 411         gTitle += "_NSide";
 412         fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gTitle.Data(),
 413                                                              gTitle.Data(),
 414                                                              AliITSgeomTGeo::GetNDetectors(iLayer),
 415                                                              0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
 416         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
 417         fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitle("Module number");
 418         fHistSSDOccupancyLadder[occupancyCounter]->GetYaxis()->SetTitle("Occupancy [%]");
 419         fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
 420                                             fGenOffset+fSSDRawsOffset);
 421         occupancyCounter += 1; fSSDRawsOffset += 1;
 422       }//ladder loop
 423     }//layer loop
 424
 425     //top level occupancy plots
 426     //occupancy per module - no threshold
 427     TH2D *fHistSSDOccupancyLayer5 = new TH2D("fHistSSDOccupancyLayer5",
 428                                              ";N_{modules};N_{Ladders}",
 429                                              fgkSSDMODULESPERLADDERLAYER5,
 430                                              0,fgkSSDMODULESPERLADDERLAYER5,
 431                                              3*fgkSSDLADDERSLAYER5,
 432                                              0,fgkSSDLADDERSLAYER5);
 433     fHistSSDOccupancyLayer5->SetTitle("Occupancy per module (Layer 5) - No threshold");
 434     Char_t fLabel[3];
 435     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 436       sprintf(fLabel,"%d",iBin);
 437       fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 438     }
 439     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5, fGenOffset+fSSDRawsOffset);
 440     fSSDRawsOffset += 1;
 441     TH2D *fHistSSDOccupancyLayer6 = new TH2D("fHistSSDOccupancyLayer6",
 442                                              ";N_{modules};N_{Ladders}",
 443                                              fgkSSDMODULESPERLADDERLAYER6,
 444                                              0,fgkSSDMODULESPERLADDERLAYER6,
 445                                              3*fgkSSDLADDERSLAYER6,
 446                                              0,fgkSSDLADDERSLAYER6);
 447     fHistSSDOccupancyLayer6->SetTitle("Occupancy per module (Layer 6) - No threshold");
 448     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 449       sprintf(fLabel,"%d",iBin);
 450       fHistSSDOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 451     }
 452     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, fGenOffset+fSSDRawsOffset);
 453     fSSDRawsOffset += 1;
 454
 455     //occupancy per module - threshold @ 3%
 456     TH2D *fHistSSDOccupancyThresholdLayer5 = new TH2D("fHistSSDOccupancyThresholdLayer5",
 457                                              ";N_{modules};N_{Ladders}",
 458                                              fgkSSDMODULESPERLADDERLAYER5,
 459                                              0,fgkSSDMODULESPERLADDERLAYER5,
 460                                              3*fgkSSDLADDERSLAYER5,
 461                                              0,fgkSSDLADDERSLAYER5);
 462     fHistSSDOccupancyThresholdLayer5->SetTitle("Occupancy per module (Layer 5) - Threshold 3%");
 463      for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 464       sprintf(fLabel,"%d",iBin);
 465       fHistSSDOccupancyThresholdLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 466     }
 467     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5, fGenOffset+fSSDRawsOffset);
 468     fSSDRawsOffset += 1;
 469     TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("fHistSSDOccupancyThresholdLayer6",
 470                                              ";N_{modules};N_{Ladders}",
 471                                              fgkSSDMODULESPERLADDERLAYER6,
 472                                              0,fgkSSDMODULESPERLADDERLAYER6,
 473                                              3*fgkSSDLADDERSLAYER6,
 474                                              0,fgkSSDLADDERSLAYER6);
 475     fHistSSDOccupancyThresholdLayer6->SetTitle("Occupancy per module (Layer 6) - Threshold 3%");
 476     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 477       sprintf(fLabel,"%d",iBin);
 478       fHistSSDOccupancyThresholdLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 479     }
 480     fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6, fGenOffset+fSSDRawsOffset);
 481     fSSDRawsOffset += 1;
 482
 483     //Average occupancy per module
 484     TH2D *fHistSSDAverageOccupancyLayer5 = new TH2D("fHistSSDAverageOccupancyLayer5",
 485                                              ";N_{modules};N_{Ladders}",
 486                                              fgkSSDMODULESPERLADDERLAYER5,
 487                                              0,fgkSSDMODULESPERLADDERLAYER5,
 488                                              3*fgkSSDLADDERSLAYER5,
 489                                              0,fgkSSDLADDERSLAYER5);
 490     fHistSSDAverageOccupancyLayer5->SetTitle("Average occupancy per module (Layer 5)");
 491     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
 492       sprintf(fLabel,"%d",iBin);
 493       fHistSSDAverageOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
 494     }
 495     fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer5, fGenOffset+fSSDRawsOffset);
 496     fSSDRawsOffset += 1;
 497     TH2D *fHistSSDAverageOccupancyLayer6 = new TH2D("fHistSSDAverageOccupancyLayer6",
 498                                              ";N_{modules};N_{Ladders}",
 499                                              fgkSSDMODULESPERLADDERLAYER6,
 500                                              0,fgkSSDMODULESPERLADDERLAYER6,
 501                                              3*fgkSSDLADDERSLAYER6,
 502                                              0,fgkSSDLADDERSLAYER6);
 503     fHistSSDAverageOccupancyLayer6->SetTitle("Average occupancy per module (Layer 6)");
 504     for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER6 + 1; iBin++){
 505       sprintf(fLabel,"%d",iBin);
 506       fHistSSDAverageOccupancyLayer6->GetXaxis()->SetBinLabel(iBin,fLabel);
 507     }
 508     fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6, fGenOffset+fSSDRawsOffset);
 509     fSSDRawsOffset += 1;
 510
 511     //Output of the DA
 512     TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5",
 513                                                    "Layer 5;N_{module};N_{ladder}",
 514                                                    22,1,23,
 515                                                    34,500,534);
 516     fHistPSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
 517     fHistPSideBadChannelMapLayer5->SetStats(kFALSE);
 518     fHistPSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 519     fHistPSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);
 520     fHistPSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);
 521     fHistPSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);
 522     fHistPSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);
 523     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 524     fHistPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
 525     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset);
 526     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 527
 528     TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5",
 529                                                    "Layer 5;N_{module};N_{ladder}",
 530                                                    22,1,23,
 531                                                    34,500,534);
 532     fHistNSideBadChannelMapLayer5->GetXaxis()->SetTitleColor(1);
 533     fHistNSideBadChannelMapLayer5->SetStats(kFALSE);
 534     fHistNSideBadChannelMapLayer5->GetYaxis()->SetTitleOffset(1.8);
 535     fHistNSideBadChannelMapLayer5->GetXaxis()->SetNdivisions(22);
 536     fHistNSideBadChannelMapLayer5->GetYaxis()->SetNdivisions(34);
 537     fHistNSideBadChannelMapLayer5->GetXaxis()->SetLabelSize(0.03);
 538     fHistNSideBadChannelMapLayer5->GetYaxis()->SetLabelSize(0.03);
 539     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
 540     fHistNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
 541     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer5, fGenOffset+fSSDRawsOffset);
 542     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 543
 544     TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6",
 545                                                    "Layer 6;N_{module};N_{ladder}",
 546                                                    25,1,26,
 547                                                    38,600,638);
 548     fHistPSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
 549     fHistPSideBadChannelMapLayer6->SetStats(kFALSE);
 550     fHistPSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 551     fHistPSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);
 552     fHistPSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);
 553     fHistPSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);
 554     fHistPSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);
 555     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 556     fHistPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
 557     fAliITSQADataMakerRec->Add2RawsList(fHistPSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset);
 558     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 559
 560     TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6",
 561                                                    "Layer 6;N_{module};N_{ladder}",
 562                                                    25,1,26,
 563                                                    38,600,638);
 564     fHistNSideBadChannelMapLayer6->GetXaxis()->SetTitleColor(1);
 565     fHistNSideBadChannelMapLayer6->SetStats(kFALSE);
 566     fHistNSideBadChannelMapLayer6->GetYaxis()->SetTitleOffset(1.8);
 567     fHistNSideBadChannelMapLayer6->GetXaxis()->SetNdivisions(25);
 568     fHistNSideBadChannelMapLayer6->GetYaxis()->SetNdivisions(38);
 569     fHistNSideBadChannelMapLayer6->GetXaxis()->SetLabelSize(0.03);
 570     fHistNSideBadChannelMapLayer6->GetYaxis()->SetLabelSize(0.03);
 571     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
 572     fHistNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
 573     fAliITSQADataMakerRec->Add2RawsList(fHistNSideBadChannelMapLayer6, fGenOffset+fSSDRawsOffset);
 574     fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
 575   }//online flag
 576   fSSDhTask = fSSDRawsOffset;
 577   AliDebug(1,Form("%d SSD Raws histograms booked\n",fSSDhTask));
 578   AliInfo(Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDhTask));
 579   AliDebug(1,Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenOffset+fSSDRawsOffset));
 580 }
 581
 582 //____________________________________________________________________________
 583 void AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) {
 584   // Fill QA for RAW - SSD -
 585   Int_t gStripNumber;
 586   Int_t gHistPosition;
 587   Int_t gLayer = 0,gLadder = 0, gModule = 0;
 588
 589   Double_t gSizePerDDL[fgkNumOfDDLs] = {0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.,0.};
 590   Double_t gSizePerLDC[fgkNumOfLDCs] = {0.,0.,0.};
 591   Double_t sumSSDDataSize = 0.0;
 592   Double_t eventSize = -1.0;
 593
 594   if(fkOnline) {
 595     //reset the signal vs strip number histograms
 596     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
 597       fHistSSDRawSignalModule[iModule]->Reset();
 598   }//online flag
 599
 600   rawReader->Select("ITSSSD",-1,-1);
 601   rawReader->Reset(); //rawReader->NextEvent();
 602   (fAliITSQADataMakerRec->GetRawsData(fGenOffset))->Fill(rawReader->GetType());
 603   if(rawReader->GetType() == 7) {
 604     fSSDEvent += 1;
 605     fSSDEventPerCycle += 1;
 606   }
 607
 608   AliITSRawStreamSSD gSSDStream(rawReader);
 609   AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
 610   if(rootReader) {
 611     const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
 612     if(header)
 613       eventSize = header->GetEventSize();
 614   }
 615   while (gSSDStream.Next()) {
 616     if(gSSDStream.GetModuleID() < 0) continue;
 617     /*cout<<"DDL: "<<rawReader->GetDDLID()<<
 618       " - LDC: "<<rawReader->GetLDCId()<<
 619       " - Size: "<<rawReader->GetDataSize()<<
 620       " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/
 621     gSizePerDDL[rawReader->GetDDLID()] = rawReader->GetDataSize();
 622     gSizePerLDC[rawReader->GetLDCId()-6] = rawReader->GetDataSize();
 623     AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
 624     if(gSSDStream.GetStrip() < 0) continue;
 625     gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
 626     gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
 627     //AliInfo(Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
 628     if(fkOnline)
 629       fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
 630     //fAliITSQADataMakerRec->GetRawsData(fGenOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());
 631   }//streamer loop
 632
 633   //event size calculation and filling info
 634   for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
 635     sumSSDDataSize += gSizePerDDL[i];
 636     if(gSizePerDDL[i] > 0) {
 637       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+3))->Fill(i+512);
 638       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+5+i))->Fill(TMath::Log10(gSizePerDDL[i]));
 639     }
 640     //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4))->Fill(i+512,gSizePerDDL[i]/1e+06);
 641   }
 642   for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
 643     if(gSizePerLDC[i] > 0) {
 644       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+21))->Fill(i+6);
 645       //LDC 082
 646       if(i == 0)
 647         gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9] + gSizePerDDL[10] +
 648           gSizePerDDL[11] + gSizePerDDL[12] + gSizePerDDL[13];
 649       //LDC 086
 650       if(i == 1)
 651         gSizePerLDC[i] = gSizePerDDL[3] + gSizePerDDL[4] + gSizePerDDL[5] +
 652           gSizePerDDL[6] + gSizePerDDL[7];
 653       //LDC 085
 654       if(i == 2)
 655         gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1] + gSizePerDDL[2] +
 656           gSizePerDDL[14] + gSizePerDDL[15];
 657       (fAliITSQADataMakerRec->GetRawsData(fGenOffset+23+i))->Fill(TMath::Log10(gSizePerLDC[i]));
 658       //cout<<"Event: "<<fSSDEventPerCycle<<" - LDC: "<<i+6<<
 659       //" - Data size: "<<gSizePerLDC[i]<<endl;
 660     }
 661     //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22))->Fill(i+6,gSizePerLDC[i]/1e+06);
 662   }
 663   if(sumSSDDataSize)
 664     (fAliITSQADataMakerRec->GetRawsData(fGenOffset+1))->Fill(TMath::Log10(sumSSDDataSize));
 665   if(eventSize)
 666     (fAliITSQADataMakerRec->GetRawsData(fGenOffset+2))->Fill(100.*sumSSDDataSize/eventSize);
 667
 668   //Occupancy calculation
 669   if(fkOnline) {
 670     for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
 671       GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]);
 672       //if(iModule == 156) {
 673         //cout<<"========================================"<<endl;
 674         //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule);
 675         /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) {
 676           if((iBin >= 750)&&(iBin <= 780))
 677           cout<<"Event: "<<fSSDEventPerCycle<<" - Ladder: "<<gLadder+499<<
 678           " - Module: "<<gModule<<" - Strip: "<<iBin<<
 679           " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl;
 680           }*///strip loop --> to be removed
 681       //}//module cut --> to be removed
 682     }//module loop
 683   }//online flag for SSD
 684 }
 685
 686 //____________________________________________________________________________ //
 687 void AliITSQASSDDataMakerRec::GetOccupancyStrip(TH1 *lHisto, Int_t *occupancyMatrix) {
 688   //Increments the entries in the occupancy matrix based
 689   //on whether the signal for each strip is larger than the cutoff
 690   //Currently the cutoff is at 0 which means that if ZS
 691   //works, whatever comes from the FEROM is considered as "signal"
 692   //Double_t cutoff = 0.0;
 693   TString histname = lHisto->GetName();
 694   //cout<<histname.Data()<<endl;
 695   //if(histname.Contains("Layer5_Ladder8_Module3")) {
 696   for(Int_t iBin = 1; iBin < lHisto->GetXaxis()->GetNbins(); iBin++) {
 697     Double_t y = lHisto->GetBinContent(iBin);
 698     if(y) {
 699       occupancyMatrix[iBin-1] += 1;
 700     }
 701     //if((iBin >= 750)&&(iBin <= 780))
 702     //cout<<"Strip: "<<iBin<<
 703     //" - Signal: "<<y<<
 704     //" - Occupancy: "<<occupancyMatrix[iBin-1]<<endl;
 705
 706   }
 707   //}
 708 }
 709
 710 //____________________________________________________________________________
 711 Double_t AliITSQASSDDataMakerRec::GetOccupancyModule(TH1 *lHisto,
 712                                                      Int_t stripside,
 713                                                      Int_t mode,
 714                                                      Double_t threshold) {
 715   //Mode 0: calculates the occupancy of a module
 716   //        without a threshold in the strip occupancy
 717   //Mode 1: calculates the occupancy of a module
 718   //        with the set threshold in the strip occupancy
 719   //Mode 2: calculates the average occupancy of a module
 720
 721   // bo: TDC >0 or # of sigmas wrt noise ?
 722   //stripside == 0 --> P-side
 723   //stripside == 1 --> N-side
 724   Int_t lNumFiredBins = 0;
 725   Double_t sumOccupancy = 0.0;
 726   TString histname = lHisto->GetName();
 727   for(Int_t iBin = 1 + stripside*fgkNumberOfPSideStrips; iBin < fgkNumberOfPSideStrips*(1 + stripside); iBin++){
 728     /*if(histname.Contains("Layer5_Ladder507_Module3")) {
 729       cout<<lHisto->GetName()<<
 730       " - Strip: "<<iBin<<
 731       " - Bin content: "<<lHisto->GetBinContent(iBin)<<endl;
 732       }*/
 733     if (lHisto->GetBinContent(iBin) > threshold) {
 734       lNumFiredBins++;
 735       sumOccupancy = lHisto->GetBinContent(iBin);
 736     }
 737   }
 738
 739   Double_t lOccupancy = 0.0;
 740   if((mode == 0)||(mode == 1))
 741     lOccupancy = (100.*lNumFiredBins)/fgkNumberOfPSideStrips; // percentage
 742   else if(mode == 2)
 743     lOccupancy = 100.*sumOccupancy/fgkNumberOfPSideStrips;
 744
 745   /*if(histname.Contains("Layer5_Ladder507_Module3"))
 746     cout<<"Fired strips: "<<lNumFiredBins<<
 747     " - Occupancy: "<<lOccupancy<<endl;*/
 748   //AliInfo(Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
 749
 750   return lOccupancy;
 751 }
 752
 753 //____________________________________________________________________________
 754 void AliITSQASSDDataMakerRec::MonitorOCDBObjects() {
 755   //Monitor in AMORE the output of the DA
 756   //Currently only the bad channel list is monitored
 757   //Todo: Noise - Pedestal
 758   AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD");
 759   if(!entryBadChannelsSSD)
 760     AliError("OCDB entry for the bad channel list is not valid!");
 761   AliITSBadChannelsSSDv2 *badchannelsSSD = (AliITSBadChannelsSSDv2 *)entryBadChannelsSSD->GetObject();
 762   if(!badchannelsSSD)
 763     AliError("Bad channel list object is not a valid AliITSBadChannelsSSD object!");
 764
 765   //_____________________________________________________________________________//
 766   Int_t nBadPSideChannels = 0, nBadNSideChannels = 0;
 767   Int_t layer = 0, ladder = 0, module = 0;
 768   Int_t nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;
 769   Int_t nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;
 770   //_____________________________________________________________________________//
 771
 772   for(Int_t i = 0; i < fgkSSDMODULES; i++) {
 773     AliITSgeomTGeo::GetModuleId(i+500,layer,ladder,module);
 774     nBadPSideChannels = 0, nBadNSideChannels = 0;
 775     nPSideChannelsLayer5 = 0, nNSideChannelsLayer5 = 0;
 776     nPSideChannelsLayer6 = 0, nNSideChannelsLayer6 = 0;
 777
 778     Int_t badChannel = 0;
 779     for(Int_t j = 0; j < fgkNumberOfPSideStrips; j++) {
 780       badChannel = (Int_t)(badchannelsSSD->GetBadChannelP(i,j));
 781       if(badChannel != 0) {
 782         if(layer == 5)
 783           nPSideChannelsLayer5 += 1;
 784         if(layer == 6)
 785           nPSideChannelsLayer6 += 1;
 786         nBadPSideChannels += 1;
 787       }//badchannel flag != 0
 788       badChannel = (Int_t)(badchannelsSSD->GetBadChannelN(i,j));
 789       if(badChannel != 0) {
 790         if(layer == 5)
 791           nNSideChannelsLayer5 += 1;
 792         if(layer == 6)
 793           nNSideChannelsLayer6 += 1;
 794         nBadNSideChannels += 1;
 795       }//badchannel flag != 0
 796     }//loop over strips
 797     if(layer == 5) {
 798       if(nPSideChannelsLayer5 > 0)
 799         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,
 800                                                                             100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips);
 801       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset))->Fill(module,499+ladder,0.0001);
 802       if(nNSideChannelsLayer5 > 0)
 803         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,
 804                                                                             100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips);
 805       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+1))->Fill(module,499+ladder,0.0001);
 806     }//layer 5
 807     if(layer == 6) {
 808       if(nPSideChannelsLayer6 > 0)
 809         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,
 810                                                                             100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips);
 811       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+2))->Fill(module,599+ladder,0.0001);
 812       if(nNSideChannelsLayer6 > 0)
 813         ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,
 814                                                                             100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips);
 815       else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsOffset-fSSDRawsDAOffset+3))->Fill(module,599+ladder,0.0001);
 816     }//layer 6
 817   }//module loop
 818 }
 819
 820 //____________________________________________________________________________
 821 void AliITSQASSDDataMakerRec::InitRecPoints()
 822 {
 823   // Initialization for RECPOINTS - SSD -
 824
 825   fGenOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();
 826   Int_t nModuleOffset = 500;
 827   Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
 828
 829   TH1F *fHistModuleIdLayer5 = new TH1F("fHistModuleIdLayer5",
 830                                        "Module Id - Layer 5;Module Id;Entries",
 831                                        fgkSSDMODULESLAYER5,
 832                                        nModuleOffset - 0.5,
 833                                        nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
 834   fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer5,
 835                                            fGenOffset + 0);
 836   fSSDhTask += 1;
 837   TH1F *fHistModuleIdLayer6 = new TH1F("fHistModuleIdLayer6",
 838                                        "Module Id - Layer 6;Module Id;Entries",
 839                                        fgkSSDMODULESLAYER6,
 840                                        nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
 841                                        nITSTotalModules + 0.5);
 842   fAliITSQADataMakerRec->Add2RecPointsList(fHistModuleIdLayer6,
 843                                            fGenOffset + 1);
 844   fSSDhTask += 1;
 845   TH1F *fHistClusterPerEventLayer5 = new TH1F("fHistClusterPerEventLayer5",
 846                                               "N_{clusters} - Layer 5;N_{clusters};Entries;",
 847                                               100,0.1,5000);
 848   fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer5,
 849                                            fGenOffset + 2);
 850   fSSDhTask += 1;
 851   TH1F *fHistClusterPerEventLayer6 = new TH1F("fHistClusterPerEventLayer6",
 852                                               "N_{clusters} - Layer 6;N_{clusters};Entries;",
 853                                               100,0.1,5000);
 854   fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer6,
 855                                            fGenOffset + 3);
 856   fSSDhTask += 1;
 857   TH1F *fHistLocalXLayer5 = new TH1F("fHistLocalXLayer5",
 858                                      "Local x coord.- Layer 5;x [cm];Entries;",
 859                                      100,-4.,4.);
 860   fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer5,
 861                                            fGenOffset + 4);
 862   fSSDhTask += 1;
 863   TH1F *fHistLocalXLayer6 = new TH1F("fHistLocalXLayer6",
 864                                      "Local x coord.- Layer 6;x [cm];Entries;",
 865                                      100,-4.,4.);
 866   fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer6,
 867                                            fGenOffset + 5);
 868   fSSDhTask += 1;
 869   TH1F *fHistLocalZLayer5 = new TH1F("fHistLocalZLayer5",
 870                                      "Local z coord.- Layer 5;z [cm];Entries;",
 871                                      100,-4.,4.);
 872   fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer5,
 873                                            fGenOffset + 6);
 874   fSSDhTask += 1;
 875   TH1F *fHistLocalZLayer6 = new TH1F("fHistLocalZLayer6",
 876                                      "Local z coord.- Layer 6;z [cm];Entries;",
 877                                      100,-4.,4.);
 878   fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer6,
 879                                            fGenOffset + 7);
 880   fSSDhTask += 1;
 881   TH1F *fHistGlobalXLayer5 = new TH1F("fHistGlobalXLayer5",
 882                                       "Global x - Layer 5;x [cm];Entries;",
 883                                       100,-40.,40.);
 884   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer5,
 885                                            fGenOffset + 8);
 886   fSSDhTask += 1;
 887   TH1F *fHistGlobalXLayer6 = new TH1F("fHistGlobalXLayer6",
 888                                       "Global x - Layer 6;x [cm];Entries;",
 889                                       100,-45.,45.);
 890   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer6,
 891                                            fGenOffset + 9);
 892   fSSDhTask += 1;
 893   TH1F *fHistGlobalYLayer5 = new TH1F("fHistGlobalYLayer5",
 894                                       "Global y - Layer 5;y [cm];Entries;",
 895                                       100,-40.,40);
 896   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer5,
 897                                            fGenOffset + 10);
 898   fSSDhTask += 1;
 899   TH1F *fHistGlobalYLayer6 = new TH1F("fHistGlobalYLayer6",
 900                                       "Global y - Layer 6;y [cm];Entries;",
 901                                       100,-45.,45.);
 902   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer6,
 903                                            fGenOffset + 11);
 904   fSSDhTask += 1;
 905   TH1F *fHistGlobalZLayer5 = new TH1F("fHistGlobalZLayer5",
 906                                       "Global z - Layer 5;z [cm];Entries;",
 907                                       100,-45.,45);
 908   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer5,
 909                                            fGenOffset + 12);
 910   fSSDhTask += 1;
 911   TH1F *fHistGlobalZLayer6 = new TH1F("fHistGlobalZLayer6",
 912                                       "Global z - Layer 6;z [cm];Entries;",
 913                                       100,-55.,55.);
 914   fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer6,
 915                                            fGenOffset + 13);
 916   fSSDhTask += 1;
 917   TH1F *fHistPhiLayer5 = new TH1F("fHistPhiLayer5",
 918                                   "#phi - Layer 5;#phi [rad];Entries;",
 919                                   100,-TMath::Pi(),TMath::Pi());
 920   fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer5,
 921                                            fGenOffset + 14);
 922   fSSDhTask += 1;
 923   TH1F *fHistPhiLayer6 = new TH1F("fHistPhiLayer6",
 924                                   "#phi - Layer 6;#phi [rad];Entries;",
 925                                   100,-TMath::Pi(),TMath::Pi());
 926   fAliITSQADataMakerRec->Add2RecPointsList(fHistPhiLayer6,
 927                                            fGenOffset + 15);
 928   fSSDhTask += 1;
 929   TH1F *fHistThetaLayer5 = new TH1F("fHistThetaLayer5",
 930                                     "#theta - Layer 5;#theta [rad];Entries;",
 931                                     100,-TMath::Pi(),TMath::Pi());
 932   fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer5,
 933                                            fGenOffset + 16);
 934   fSSDhTask += 1;
 935   TH1F *fHistThetaLayer6 = new TH1F("fHistThetaLayer6",
 936                                     "#theta - Layer 6;#theta [rad];Entries;",
 937                                     100,-TMath::Pi(),TMath::Pi());
 938   fAliITSQADataMakerRec->Add2RecPointsList(fHistThetaLayer6,
 939                                            fGenOffset + 17);
 940   fSSDhTask += 1;
 941   TH1F *fHistRadiusLayer5 = new TH1F("fHistRadiusLayer5",
 942                                      "r - Layer 5;r [cm];Entries;",
 943                                      100,35.,50.);
 944   fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer5,
 945                                            fGenOffset + 18);
 946   fSSDhTask += 1;
 947   TH1F *fHistRadiusLayer6 = new TH1F("fHistRadiusLayer6",
 948                                      "r - Layer 6;r [cm];Entries;",
 949                                      100,35.,50.);
 950   fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer6,
 951                                            fGenOffset + 19);
 952   fSSDhTask += 1;
 953   TH1F *fHistClusterTypeLayer5 = new TH1F("fHistClusterTypeLayer5",
 954                                           "CL type - Layer 5;Cluster type;Entries;",
 955                                           150,0,150);
 956   fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer5,
 957                                            fGenOffset + 20);
 958   fSSDhTask += 1;
 959   TH1F *fHistClusterTypeLayer6 = new TH1F("fHistClusterTypeLayer6",
 960                                           "CL type - Layer 6;Cluster type;Entries;",
 961                                           150,0,150);
 962   fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer6,
 963                                            fGenOffset + 21);
 964   fSSDhTask += 1;
 965   TH1F *fHistChargeRatioLayer5 = new TH1F("fHistChargeRatioLayer5",
 966                                           "Charge ratio - Layer 5;q_{ratio};Entries;",
 967                                           100,-2.0,2.0);
 968   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer5,
 969                                            fGenOffset + 22);
 970   fSSDhTask += 1;
 971   TH1F *fHistChargeRatioLayer6 = new TH1F("fHistChargeRatioLayer6",
 972                                           "Charge ratio - Layer 6;q_{ratio};Entries;",
 973                                           100,-2.0,2.0);
 974   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer6,
 975                                            fGenOffset + 23);
 976   fSSDhTask += 1;
 977   TH1F *fHistChargekeVLayer5 = new TH1F("fHistChargekeVLayer5",
 978                                         "Charge - Layer 5;q [keV];Entries;",
 979                                         100,0.,300.);
 980   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer5,
 981                                            fGenOffset + 24);
 982   fSSDhTask += 1;
 983   TH1F *fHistChargekeVLayer6 = new TH1F("fHistChargekeVLayer6",
 984                                         "Charge - Layer 6;q [keV];Entries;",
 985                                         100,0.,300.);
 986   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer6,
 987                                            fGenOffset + 25);
 988   fSSDhTask += 1;
 989   TH1F *fHistChargePSideLayer5 = new TH1F("fHistChargePSideLayer5",
 990                                           "Charge P- Layer 5;q_{P} [keV];Entries;",
 991                                           100,0.,300.);
 992   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer5,
 993                                            fGenOffset + 26);
 994   fSSDhTask += 1;
 995   TH1F *fHistChargePSideLayer6 = new TH1F("fHistChargePSideLayer6",
 996                                           "Charge P- Layer 6;q_{P} [keV];Entries;",
 997                                           100,0.,300.);
 998   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer6,
 999                                            fGenOffset + 27);
1000   fSSDhTask += 1;
1001   TH1F *fHistChargeNSideLayer5 = new TH1F("fHistChargeNSideLayer5",
1002                                           "Charge N- Layer 5;q_{N} [keV];Entries;",
1003                                           100,0.,300.);
1004   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer5,
1005                                            fGenOffset + 28);
1006   fSSDhTask += 1;
1007   TH1F *fHistChargeNSideLayer6 = new TH1F("fHistChargeNSideLayer6",
1008                                           "Charge N- Layer 6;q_{N} [keV];Entries;",
1009                                           100,0.,300.);
1010   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer6,
1011                                            fGenOffset + 29);
1012   fSSDhTask += 1;
1013   TH1F *fHistChargeRatio2Layer5 = new TH1F("fHistChargeRatio2Layer5",
1014                                           "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
1015                                           100,0,2);
1016   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer5,
1017                                            fGenOffset + 30);
1018   fSSDhTask += 1;
1019   TH1F *fHistChargeRatio2Layer6 = new TH1F("fHistChargeRatio2Layer6",
1020                                            "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
1021                                            100,0,2);
1022   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer6,
1023                                            fGenOffset + 31);
1024   fSSDhTask += 1;
1025   TH2F *fHistChargePNSideLayer5 = new TH2F("fHistChargePNSideLayer5",
1026                                            "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
1027                                            100,0.,300.,
1028                                            100,0.,300.);
1029   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer5,
1030                                            fGenOffset + 32);
1031   fSSDhTask += 1;
1032   TH2F *fHistChargePNSideLayer6 = new TH2F("fHistChargePNSideLayer6",
1033                                            "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
1034                                            100,0.,300.,
1035                                            100,0.,300.);
1036   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer6,
1037                                            fGenOffset + 33);
1038   fSSDhTask += 1;
1039   TH2F *fHistChargeMapLayer5 = new TH2F("fHistChargeMapLayer5",
1040                                         "Charge map;N_{modules};N_{Ladders}",
1041                                         fgkSSDMODULESPERLADDERLAYER5,
1042                                         -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,
1043                                         3*fgkSSDLADDERSLAYER5,
1044                                         -0.5,fgkSSDLADDERSLAYER5+0.5);
1045   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer5,
1046                                            fGenOffset + 34);
1047   fSSDhTask += 1;
1048   TH2F *fHistChargeMapLayer6 = new TH2F("fHistChargeMapLayer6",
1049                                         "Charge map;N_{modules};N_{Ladders}",
1050                                         fgkSSDMODULESPERLADDERLAYER6,
1051                                         -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,
1052                                         3*fgkSSDLADDERSLAYER6,
1053                                         -0.5,fgkSSDLADDERSLAYER6+0.5);
1054   fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeMapLayer6,
1055                                            fGenOffset + 35);
1056   fSSDhTask += 1;
1057
1058   AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhTask));
1059 }
1060
1061 //____________________________________________________________________________
1062 void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree)
1063 {
1064   // Fill QA for recpoints - SSD -
1065
1066   Int_t gLayer = 0, gLadder = 0, gModule = 0;
1067   Int_t lLadderLocationY = 0;
1068   TBranch *branchRecP = clustersTree->GetBranch("ITSRecPoints");
1069   if (!branchRecP) {
1070     AliError("can't get the branch with the ITS clusters !");
1071     return;
1072   }
1073   static TClonesArray statRecpoints("AliITSRecPoint");
1074   TClonesArray *recpoints = &statRecpoints;
1075   branchRecP->SetAddress(&recpoints);
1076   Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;
1077   Int_t npoints = 0;
1078   Float_t cluglo[3]={0.,0.,0.};
1079   for(Int_t module = 0; module < clustersTree->GetEntries(); module++){
1080     branchRecP->GetEvent(module);
1081     npoints += recpoints->GetEntries();
1082     AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);
1083     lLadderLocationY = 3*gLadder;
1084
1085     for(Int_t j = 0;j < recpoints->GetEntries(); j++){
1086       AliITSRecPoint *recp = (AliITSRecPoint*)recpoints->At(j);
1087       Int_t layer = recp->GetLayer();
1088       recp->GetGlobalXYZ(cluglo);
1089       Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]);
1090       Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);
1091       Float_t theta = TMath::ATan2(radius,cluglo[2]);
1092       Double_t chargeRatio = recp->GetChargeRatio();
1093       Double_t clusterCharge = recp->GetQ();
1094       Double_t chargePSide = clusterCharge*(1. + chargeRatio);
1095       Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
1096       if(layer == 4) {
1097         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 0)->Fill(module);
1098         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 4)->Fill(recp->GetDetLocalX());
1099         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 6)->Fill(recp->GetDetLocalZ());
1100         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 8)->Fill(cluglo[0]);
1101         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 10)->Fill(cluglo[1]);
1102         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 12)->Fill(cluglo[2]);
1103         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 14)->Fill(phi);
1104         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 16)->Fill(theta);
1105         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 18)->Fill(radius);
1106         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 20)->Fill(recp->GetType());
1107         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 22)->Fill(recp->GetChargeRatio());
1108         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 24)->Fill(recp->GetQ());
1109         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 26)->Fill(chargePSide);
1110         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 28)->Fill(chargeNSide);
1111         if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 30)->Fill(chargeNSide/chargePSide);
1112         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 32)->Fill(chargePSide,chargeNSide);
1113         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 34)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
1114         nClustersLayer5 += 1;
1115       }//layer 5 histograms
1116       if(layer == 5) {
1117         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 1)->Fill(module);
1118         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 5)->Fill(recp->GetDetLocalX());
1119         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 7)->Fill(recp->GetDetLocalZ());
1120         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 9)->Fill(cluglo[0]);
1121         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 11)->Fill(cluglo[1]);
1122         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 13)->Fill(cluglo[2]);
1123         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 15)->Fill(phi);
1124         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 17)->Fill(theta);
1125         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 19)->Fill(radius);
1126         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 21)->Fill(recp->GetType());
1127         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 23)->Fill(recp->GetChargeRatio());
1128         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 25)->Fill(recp->GetQ());
1129         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 27)->Fill(chargePSide);
1130         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 29)->Fill(chargeNSide);
1131         if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 31)->Fill(chargeNSide/chargePSide);
1132         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 33)->Fill(chargePSide,chargeNSide);
1133         fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 35)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
1134         nClustersLayer6 += 1;
1135       }//layer 6 histograms
1136     }//rec. points loop
1137   }//module loop
1138
1139   fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 2)->Fill(nClustersLayer5);
1140   fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 3)->Fill(nClustersLayer6);
1141
1142   statRecpoints.Clear();
1143 }
1144