1 /**************************************************************************
\r
2 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
\r
4 * Author: The ALICE Off-line Project. *
\r
5 * Contributors are mentioned in the code where appropriate. *
\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
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
24 // --- ROOT system ---
\r
28 #include <TString.h>
\r
29 #include <TSystem.h>
\r
31 // --- Standard library ---
\r
33 // --- AliRoot header files ---
\r
34 #include "AliITSQASSDDataMakerRec.h"
\r
35 #include "AliQADataMakerRec.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
47 #include "AliCDBManager.h"
\r
48 #include "AliCDBEntry.h"
\r
50 ClassImp(AliITSQASSDDataMakerRec)
\r
52 AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :
\r
54 fAliITSQADataMakerRec(aliITSQADataMakerRec),
\r
56 fSSDEventPerCycle(0),
\r
59 fSSDRawsOffset(0), fSSDRawsDAOffset(0),
\r
60 fSSDRawsCommonLevelOffset(0),
\r
64 // Default constructor
\r
65 //initilize the raw signal vs strip number histograms
\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
72 AliInfo("DATE_RUN_NUMBER not defined!!!\n");
\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
78 Int_t gLayer = 0,gLadder = 0, gModule = 0;
\r
79 Int_t gHistCounter = 0;
\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
91 for(Int_t iStrip = 0; iStrip < 2*fgkNumberOfPSideStrips; iStrip++)
\r
92 fOccupancyMatrix[iModule-500][iStrip] = 0;
\r
96 for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
\r
97 fHistSSDRawSignalModule[iModule]=NULL;
\r
102 //____________________________________________________________________________
\r
103 AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :
\r
105 fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
\r
106 fSSDEvent(qadm.fSSDEvent),
\r
107 fSSDEventPerCycle(qadm.fSSDEventPerCycle),
\r
108 fkOnline(qadm.fkOnline),
\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
116 fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
\r
117 fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
\r
120 //__________________________________________________________________
\r
121 AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )
\r
124 this->~AliITSQASSDDataMakerRec();
\r
125 new(this) AliITSQASSDDataMakerRec(qac);
\r
129 //__________________________________________________________________
\r
130 AliITSQASSDDataMakerRec::~AliITSQASSDDataMakerRec() {
\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
137 //____________________________________________________________________________
\r
138 void AliITSQASSDDataMakerRec::StartOfDetectorCycle()
\r
140 //Detector specific actions at start of cycle
\r
142 if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
\r
145 AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
\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
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
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
164 gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
\r
167 fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();
\r
169 fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();
\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
177 //____________________________________________________________________________
\r
178 void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list)
\r
180 // launch the QA checking
\r
181 if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
\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
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
200 MonitorOCDBObjects();
\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
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
212 if(fSSDEventPerCycle != 0)
\r
213 ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)))->Scale(100./fSSDEventPerCycle);
\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
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
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
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
236 occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1);
\r
237 fAliITSQADataMakerRec->GetRawsData(fGenOffset+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Fill(gModule,occupancy);
\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
243 }//online flag for SSD
\r
245 fSSDEventPerCycle = 0;
\r
247 AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
\r
250 //____________________________________________________________________________
\r
251 void AliITSQASSDDataMakerRec::InitRaws() {
\r
252 // Initialization for RAW data - SSD -
\r
253 fGenOffset = (fAliITSQADataMakerRec->fRawsQAList)->GetEntries();
\r
256 AliInfo("Book Online Histograms for SSD\n");
\r
259 AliInfo("Book Offline Histograms for SSD\n ");
\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
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
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
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
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
299 fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1],
\r
300 fGenOffset+fSSDRawsOffset);
\r
301 fSSDRawsOffset += 1;
\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
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
323 fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1],
\r
324 fGenOffset+fSSDRawsOffset);
\r
325 fSSDRawsOffset += 1;
\r
327 fSSDRawsCommonLevelOffset = fSSDRawsOffset;
\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
338 gTitle += 499+gLadder;
\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
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
360 gTitle += 499+iLadder;
\r
362 gTitle += 599+iLadder;
\r
363 gTitle += "_PSide";
\r
364 fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(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
378 gTitle += 499+iLadder;
\r
380 gTitle += 599+iLadder;
\r
381 gTitle += "_NSide";
\r
382 fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(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
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
403 for(Int_t iBin = 1; iBin < fgkSSDMODULESPERLADDERLAYER5 + 1; iBin++){
\r
404 sprintf(fLabel,"%d",iBin);
\r
405 fHistSSDOccupancyLayer5->GetXaxis()->SetBinLabel(iBin,fLabel);
\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
419 fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6, fGenOffset+fSSDRawsOffset);
\r
420 fSSDRawsOffset += 1;
\r
423 TH2D *fHistPSideBadChannelMapLayer5 = new TH2D("fHistPSideBadChannelMapLayer5",
\r
424 "Layer 5;N_{module};N_{ladder}",
\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
439 TH2D *fHistNSideBadChannelMapLayer5 = new TH2D("fHistNSideBadChannelMapLayer5",
\r
440 "Layer 5;N_{module};N_{ladder}",
\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
455 TH2D *fHistPSideBadChannelMapLayer6 = new TH2D("fHistPSideBadChannelMapLayer6",
\r
456 "Layer 6;N_{module};N_{ladder}",
\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
471 TH2D *fHistNSideBadChannelMapLayer6 = new TH2D("fHistNSideBadChannelMapLayer6",
\r
472 "Layer 6;N_{module};N_{ladder}",
\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
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
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
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
506 //reset the signal vs strip number histograms
\r
507 for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
\r
508 fHistSSDRawSignalModule[iModule]->Reset();
\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
516 fSSDEventPerCycle += 1;
\r
519 AliITSRawStreamSSD gSSDStream(rawReader);
\r
520 AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
\r
522 const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
\r
524 eventSize = header->GetEventSize();
\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
540 fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
\r
541 //fAliITSQADataMakerRec->GetRawsData(fGenOffset+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());
\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
551 //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+4))->Fill(i+512,gSizePerDDL[i]/1e+06);
\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
558 gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9] + gSizePerDDL[10] +
\r
559 gSizePerDDL[11] + gSizePerDDL[12] + gSizePerDDL[13];
\r
562 gSizePerLDC[i] = gSizePerDDL[3] + gSizePerDDL[4] + gSizePerDDL[5] +
\r
563 gSizePerDDL[6] + gSizePerDDL[7];
\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
572 //(fAliITSQADataMakerRec->GetRawsData(fGenOffset+22))->Fill(i+6,gSizePerLDC[i]/1e+06);
\r
574 if(sumSSDDataSize)
\r
575 (fAliITSQADataMakerRec->GetRawsData(fGenOffset+1))->Fill(TMath::Log10(sumSSDDataSize));
\r
577 (fAliITSQADataMakerRec->GetRawsData(fGenOffset+2))->Fill(100.*sumSSDDataSize/eventSize);
\r
579 //Occupancy calculation
\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
594 }//online flag for SSD
\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
610 occupancyMatrix[iBin-1] += 1;
\r
612 //if((iBin >= 750)&&(iBin <= 780))
\r
613 //cout<<"Strip: "<<iBin<<
\r
614 //" - Signal: "<<y<<
\r
615 //" - Occupancy: "<<occupancyMatrix[iBin-1]<<endl;
\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
634 if (lHisto->GetBinContent(iBin) > 0)
\r
638 Double_t lOccupancy = (100.*lNumFiredBins)/fgkNumberOfPSideStrips; // percentage
\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
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
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
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
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
678 nPSideChannelsLayer5 += 1;
\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
686 nNSideChannelsLayer5 += 1;
\r
688 nNSideChannelsLayer6 += 1;
\r
689 nBadNSideChannels += 1;
\r
690 }//badchannel flag != 0
\r
691 }//loop over strips
\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
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
715 //____________________________________________________________________________
\r
716 void AliITSQASSDDataMakerRec::InitRecPoints()
\r
718 // Initialization for RECPOINTS - SSD -
\r
720 fGenOffset = (fAliITSQADataMakerRec->fRecPointsQAList)->GetEntries();
\r
721 Int_t nModuleOffset = 500;
\r
722 Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
\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
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
740 TH1F *fHistClusterPerEventLayer5 = new TH1F("fHistClusterPerEventLayer5",
\r
741 "N_{clusters} - Layer 5;N_{clusters};Entries;",
\r
743 fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer5,
\r
746 TH1F *fHistClusterPerEventLayer6 = new TH1F("fHistClusterPerEventLayer6",
\r
747 "N_{clusters} - Layer 6;N_{clusters};Entries;",
\r
749 fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterPerEventLayer6,
\r
752 TH1F *fHistLocalXLayer5 = new TH1F("fHistLocalXLayer5",
\r
753 "Local x coord.- Layer 5;x [cm];Entries;",
\r
755 fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer5,
\r
758 TH1F *fHistLocalXLayer6 = new TH1F("fHistLocalXLayer6",
\r
759 "Local x coord.- Layer 6;x [cm];Entries;",
\r
761 fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalXLayer6,
\r
764 TH1F *fHistLocalZLayer5 = new TH1F("fHistLocalZLayer5",
\r
765 "Local z coord.- Layer 5;z [cm];Entries;",
\r
767 fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer5,
\r
770 TH1F *fHistLocalZLayer6 = new TH1F("fHistLocalZLayer6",
\r
771 "Local z coord.- Layer 6;z [cm];Entries;",
\r
773 fAliITSQADataMakerRec->Add2RecPointsList(fHistLocalZLayer6,
\r
776 TH1F *fHistGlobalXLayer5 = new TH1F("fHistGlobalXLayer5",
\r
777 "Global x - Layer 5;x [cm];Entries;",
\r
779 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer5,
\r
782 TH1F *fHistGlobalXLayer6 = new TH1F("fHistGlobalXLayer6",
\r
783 "Global x - Layer 6;x [cm];Entries;",
\r
785 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalXLayer6,
\r
788 TH1F *fHistGlobalYLayer5 = new TH1F("fHistGlobalYLayer5",
\r
789 "Global y - Layer 5;y [cm];Entries;",
\r
791 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer5,
\r
794 TH1F *fHistGlobalYLayer6 = new TH1F("fHistGlobalYLayer6",
\r
795 "Global y - Layer 6;y [cm];Entries;",
\r
797 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalYLayer6,
\r
800 TH1F *fHistGlobalZLayer5 = new TH1F("fHistGlobalZLayer5",
\r
801 "Global z - Layer 5;z [cm];Entries;",
\r
803 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer5,
\r
806 TH1F *fHistGlobalZLayer6 = new TH1F("fHistGlobalZLayer6",
\r
807 "Global z - Layer 6;z [cm];Entries;",
\r
809 fAliITSQADataMakerRec->Add2RecPointsList(fHistGlobalZLayer6,
\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
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
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
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
836 TH1F *fHistRadiusLayer5 = new TH1F("fHistRadiusLayer5",
\r
837 "r - Layer 5;r [cm];Entries;",
\r
839 fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer5,
\r
842 TH1F *fHistRadiusLayer6 = new TH1F("fHistRadiusLayer6",
\r
843 "r - Layer 6;r [cm];Entries;",
\r
845 fAliITSQADataMakerRec->Add2RecPointsList(fHistRadiusLayer6,
\r
848 TH1F *fHistClusterTypeLayer5 = new TH1F("fHistClusterTypeLayer5",
\r
849 "CL type - Layer 5;Cluster type;Entries;",
\r
851 fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer5,
\r
854 TH1F *fHistClusterTypeLayer6 = new TH1F("fHistClusterTypeLayer6",
\r
855 "CL type - Layer 6;Cluster type;Entries;",
\r
857 fAliITSQADataMakerRec->Add2RecPointsList(fHistClusterTypeLayer6,
\r
860 TH1F *fHistChargeRatioLayer5 = new TH1F("fHistChargeRatioLayer5",
\r
861 "Charge ratio - Layer 5;q_{ratio};Entries;",
\r
863 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer5,
\r
866 TH1F *fHistChargeRatioLayer6 = new TH1F("fHistChargeRatioLayer6",
\r
867 "Charge ratio - Layer 6;q_{ratio};Entries;",
\r
869 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatioLayer6,
\r
872 TH1F *fHistChargekeVLayer5 = new TH1F("fHistChargekeVLayer5",
\r
873 "Charge - Layer 5;q [keV];Entries;",
\r
875 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer5,
\r
878 TH1F *fHistChargekeVLayer6 = new TH1F("fHistChargekeVLayer6",
\r
879 "Charge - Layer 6;q [keV];Entries;",
\r
881 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargekeVLayer6,
\r
884 TH1F *fHistChargePSideLayer5 = new TH1F("fHistChargePSideLayer5",
\r
885 "Charge P- Layer 5;q_{P} [keV];Entries;",
\r
887 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer5,
\r
890 TH1F *fHistChargePSideLayer6 = new TH1F("fHistChargePSideLayer6",
\r
891 "Charge P- Layer 6;q_{P} [keV];Entries;",
\r
893 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePSideLayer6,
\r
896 TH1F *fHistChargeNSideLayer5 = new TH1F("fHistChargeNSideLayer5",
\r
897 "Charge N- Layer 5;q_{N} [keV];Entries;",
\r
899 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer5,
\r
902 TH1F *fHistChargeNSideLayer6 = new TH1F("fHistChargeNSideLayer6",
\r
903 "Charge N- Layer 6;q_{N} [keV];Entries;",
\r
905 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeNSideLayer6,
\r
908 TH1F *fHistChargeRatio2Layer5 = new TH1F("fHistChargeRatio2Layer5",
\r
909 "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
\r
911 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer5,
\r
914 TH1F *fHistChargeRatio2Layer6 = new TH1F("fHistChargeRatio2Layer6",
\r
915 "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
\r
917 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargeRatio2Layer6,
\r
920 TH2F *fHistChargePNSideLayer5 = new TH2F("fHistChargePNSideLayer5",
\r
921 "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
\r
924 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer5,
\r
927 TH2F *fHistChargePNSideLayer6 = new TH2F("fHistChargePNSideLayer6",
\r
928 "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
\r
931 fAliITSQADataMakerRec->Add2RecPointsList(fHistChargePNSideLayer6,
\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
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
953 AliDebug(1,Form("%d SSD Recs histograms booked\n",fSSDhTask));
\r
956 //____________________________________________________________________________
\r
957 void AliITSQASSDDataMakerRec::MakeRecPoints(TTree *clustersTree)
\r
959 // Fill QA for recpoints - SSD -
\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
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
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
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
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
1034 fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 2)->Fill(nClustersLayer5);
\r
1035 fAliITSQADataMakerRec->GetRecPointsData(fGenOffset + 3)->Fill(nClustersLayer6);
\r
1037 statRecpoints.Clear();
\r