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