ITS/AliITSQASSDDataMakerRec.cxx

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