Line data Source code
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 :
16 : /* $Id$ */
17 :
18 : // *************************************************************
19 : // Checks the quality assurance
20 : // by comparing with reference data
21 : // contained in a DB
22 : // -------------------------------------------------------------
23 : // W. Ferrarese + P. Cerello Feb 2008
24 : // INFN Torino
25 : // Melinda Siciliano Aug 2008
26 :
27 :
28 : // --- ROOT system ---
29 : #include <TH2.h>
30 : // --- Standard library ---
31 :
32 : // --- AliRoot header files ---
33 : #include "AliITSQADataMakerRec.h"
34 : #include "AliITSQASPDDataMakerRec.h"
35 : #include "AliITSQASDDDataMakerRec.h"
36 : #include "AliITSQASSDDataMakerRec.h"
37 : #include "AliQAv1.h"
38 : #include "AliQAChecker.h"
39 : #include "AliITSQAChecker.h"
40 : #include "AliITSRecPoint.h"
41 : #include "AliITSRecPointContainer.h"
42 : #include "AliRawReader.h"
43 : #include "AliESDEvent.h"
44 : #include "AliESDtrack.h"
45 : #include "AliMultiplicity.h"
46 : #include "AliITSgeomTGeo.h"
47 :
48 : //class TH2;
49 : //class TH2F;
50 : class AliESDVertex;
51 : class AliLog;
52 : class TTree;
53 :
54 118 : ClassImp(AliITSQADataMakerRec)
55 :
56 : //____________________________________________________________________________
57 : AliITSQADataMakerRec::AliITSQADataMakerRec(Bool_t kMode, Short_t subDet, Short_t ldc) :
58 6 : AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
59 2 : fkOnline(kMode),
60 2 : fSubDetector(subDet),
61 2 : fLDC(ldc),
62 2 : fRunNumber(0),
63 2 : fEventNumber(0),
64 2 : fSelectedTaskIndex(AliQAv1::kNULLTASKINDEX),
65 2 : fSPDDataMaker(NULL),
66 2 : fSDDDataMaker(NULL),
67 2 : fSSDDataMaker(NULL)
68 :
69 6 : {
70 : //ctor used to discriminate OnLine-Offline analysis
71 4 : if(fSubDetector < 0 || fSubDetector > 3) {
72 0 : AliError("Error: fSubDetector number out of range; return\n");
73 : }
74 :
75 : // Initialization for RAW data
76 2 : if(fSubDetector == 0 || fSubDetector == 1) {
77 10 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SPD DataMakerRec\n");
78 6 : fSPDDataMaker = new AliITSQASPDDataMakerRec(this,fkOnline);
79 2 : }
80 2 : if(fSubDetector == 0 || fSubDetector == 2) {
81 10 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SDD DataMakerRec\n");
82 6 : fSDDDataMaker = new AliITSQASDDDataMakerRec(this,fkOnline);
83 2 : }
84 2 : if(fSubDetector == 0 || fSubDetector == 3) {
85 10 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SSD DataMakerRec\n");
86 6 : fSSDDataMaker = new AliITSQASSDDataMakerRec(this,fkOnline);
87 2 : }
88 4 : }
89 :
90 : //____________________________________________________________________________
91 0 : AliITSQADataMakerRec::~AliITSQADataMakerRec(){
92 : // destructor
93 0 : if(fSPDDataMaker)delete fSPDDataMaker;
94 0 : if(fSDDDataMaker)delete fSDDDataMaker;
95 0 : if(fSSDDataMaker)delete fSSDDataMaker;
96 0 : }
97 :
98 : //____________________________________________________________________________
99 : AliITSQADataMakerRec::AliITSQADataMakerRec(const AliITSQADataMakerRec& qadm) :
100 0 : AliQADataMakerRec(),
101 0 : fkOnline(qadm.fkOnline),
102 0 : fSubDetector(qadm.fSubDetector),
103 0 : fLDC(qadm.fLDC),
104 0 : fRunNumber(qadm.fRunNumber),
105 0 : fEventNumber(qadm.fEventNumber),
106 0 : fSelectedTaskIndex(qadm.fSelectedTaskIndex),
107 0 : fSPDDataMaker(NULL),
108 0 : fSDDDataMaker(NULL),
109 0 : fSSDDataMaker(NULL)
110 :
111 0 : {
112 : //copy ctor
113 0 : SetName((const char*)qadm.GetName()) ;
114 0 : SetTitle((const char*)qadm.GetTitle());
115 0 : }
116 :
117 : //__________________________________________________________________
118 : AliITSQADataMakerRec& AliITSQADataMakerRec::operator = (const AliITSQADataMakerRec& qac )
119 : {
120 : // Equal operator.
121 0 : this->~AliITSQADataMakerRec();
122 0 : new(this) AliITSQADataMakerRec(qac);
123 0 : return *this;
124 0 : }
125 :
126 : //____________________________________________________________________________
127 : void AliITSQADataMakerRec::StartOfDetectorCycle()
128 : {
129 : //Detector specific actions at start of cycle
130 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of ITS Cycle\n");
131 0 : ResetEventTrigClasses(); // reset triggers list to select all histos
132 0 : ResetEvCountCycle();
133 : //
134 0 : if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->StartOfDetectorCycle();
135 0 : if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->StartOfDetectorCycle();
136 0 : if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->StartOfDetectorCycle();
137 0 : }
138 :
139 : //____________________________________________________________________________
140 : void AliITSQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
141 : {
142 : // Start a cycle of QA data acquistion
143 0 : fSelectedTaskIndex=task;
144 0 : AliQADataMakerRec::StartOfCycle(task,run,sameCycle);
145 0 : }
146 :
147 : //____________________________________________________________________________
148 : void AliITSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
149 : {
150 : // launch the QA checking
151 0 : ResetEventTrigClasses();
152 : //
153 0 : AliInfo(Form("End of Dedetctor Cycle called for %s\n",AliQAv1::GetTaskName(task).Data() ));
154 : //
155 0 : for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
156 : //
157 0 : if(!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
158 0 : SetEventSpecie(AliRecoParam::ConvertIndex(specie));
159 0 : Int_t idnumber=list[specie]->GetUniqueID();
160 : //printf("specie %s \t id number == %d\n",AliRecoParam::GetEventSpecieName(specie),idnumber);
161 0 : if(idnumber==40||idnumber==0){
162 : //AliInfo(Form("No check for %s\n",AliQAv1::GetTaskName(task).Data() ))
163 0 : continue;
164 : } //skip kDigitsR and not filled TobjArray specie
165 : else{
166 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
167 0 : if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
168 0 : if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
169 0 : if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
170 :
171 :
172 0 : AliQAChecker *qac = AliQAChecker::Instance();
173 0 : AliITSQAChecker *qacb = (AliITSQAChecker *) qac->GetDetQAChecker(0);
174 0 : Int_t subdet=GetSubDet();
175 0 : qacb->SetSubDet(subdet);
176 :
177 0 : if(subdet== 0 ){
178 0 : qacb->SetTaskOffset(fSPDDataMaker->GetOffset(task,specie), fSDDDataMaker->GetOffset(task,specie), fSSDDataMaker->GetOffset(task,specie)); //Setting the offset for the QAChecker list
179 0 : qacb->SetHisto(fSPDDataMaker->GetTaskHisto(task), fSDDDataMaker->GetTaskHisto(task), fSSDDataMaker->GetTaskHisto(task));
180 0 : }
181 : else
182 0 : if(subdet!=0){
183 0 : Int_t offset=GetDetTaskOffset(subdet, task,specie);
184 0 : qacb->SetDetTaskOffset(subdet,offset);
185 0 : Int_t histo=GetDetTaskHisto(subdet, task);
186 0 : qacb->SetDetHisto(subdet,histo);
187 0 : }
188 :
189 0 : qac->Run( AliQAv1::kITS , task, list);
190 :
191 : }//end else unique id
192 :
193 0 : }//end for
194 0 : }
195 :
196 : //____________________________________________________________________________
197 : //void AliITSQADataMakerRec::EndOfDetectorCycle(const char * /*fgDataName*/)
198 : //{
199 : //eventually used for different AliQAChecker::Instance()->Run
200 : //}
201 :
202 : //____________________________________________________________________________
203 : void AliITSQADataMakerRec::InitRaws() {
204 : // Initialization of RAW data histograms
205 :
206 : //if(fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
207 :
208 0 : if(fSubDetector == 0 || fSubDetector == 1) {
209 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRaws\n");
210 0 : fSPDDataMaker->InitRaws();
211 0 : }
212 0 : if(fSubDetector == 0 || fSubDetector == 2) {
213 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRaws\n");
214 :
215 0 : fSDDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
216 0 : fSDDDataMaker->InitRaws();
217 0 : }
218 0 : if(fSubDetector == 0 || fSubDetector == 3) {
219 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRaws\n");
220 :
221 0 : fSSDDataMaker->SetOffset(AliQAv1::kRAWS, fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
222 0 : fSSDDataMaker->InitRaws();
223 0 : }
224 0 : fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(10);
225 : //
226 0 : ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
227 0 : }
228 :
229 : //____________________________________________________________________________
230 : void AliITSQADataMakerRec::MakeRaws(AliRawReader* rawReader)
231 : {
232 : // Fill QA for RAW
233 : //return ;
234 :
235 0 : SetRunNumber(rawReader->GetRunNumber());
236 :
237 0 : if(fSubDetector == 0 || fSubDetector == 1) {
238 0 : fSPDDataMaker->MakeRaws(rawReader) ;
239 0 : }
240 :
241 0 : if(fSubDetector == 0 || fSubDetector == 2) {
242 0 : fSDDDataMaker->MakeRaws(rawReader) ;
243 0 : }
244 :
245 0 : if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeRaws(rawReader);
246 : //
247 0 : IncEvCountCycleRaws();
248 0 : IncEvCountTotalRaws();
249 : //
250 0 : }
251 :
252 : //____________________________________________________________________________
253 : void AliITSQADataMakerRec::InitDigits()
254 : {
255 :
256 : // Initialization for DIGITS
257 0 : if(fSubDetector == 0 || fSubDetector == 1) {
258 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitDigits\n");
259 :
260 0 : fSPDDataMaker->InitDigits();
261 0 : }
262 0 : if(fSubDetector == 0 || fSubDetector == 2) {
263 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitDigits\n");
264 0 : fSDDDataMaker->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
265 :
266 0 : fSDDDataMaker->InitDigits();
267 0 : }
268 0 : if(fSubDetector == 0 || fSubDetector == 3) {
269 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitDigits\n");
270 0 : fSSDDataMaker->SetOffset(AliQAv1::kDIGITSR, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
271 :
272 0 : fSSDDataMaker->InitDigits();
273 0 : }
274 0 : fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(40);
275 : //
276 0 : ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
277 0 : }
278 :
279 : //____________________________________________________________________________
280 : void AliITSQADataMakerRec::MakeDigits(TTree * digitsTree)
281 : {
282 :
283 :
284 : // Fill QA for recpoints
285 0 : if(fSubDetector == 0 || fSubDetector == 1) {
286 0 : fSPDDataMaker->MakeDigits(digitsTree) ;
287 0 : }
288 :
289 0 : if(fSubDetector == 0 || fSubDetector == 2) {
290 0 : fSDDDataMaker->MakeDigits(digitsTree) ;
291 :
292 0 : }
293 :
294 0 : if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digitsTree);
295 : //
296 0 : IncEvCountCycleDigits();
297 0 : IncEvCountTotalDigits();
298 : //
299 0 : }
300 :
301 : //____________________________________________________________________________
302 : void AliITSQADataMakerRec::InitRecPoints()
303 : {
304 :
305 : // Initialization for RECPOINTS
306 :
307 :
308 : //if(fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
309 0 : if(fSubDetector == 0 || fSubDetector == 1) {
310 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRecPoints\n");
311 0 : fSPDDataMaker->InitRecPoints();
312 0 : }
313 0 : if(fSubDetector == 0 || fSubDetector == 2) {
314 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRecPoints\n");
315 0 : fSDDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(), AliRecoParam::AConvert(fEventSpecie));
316 0 : fSDDDataMaker->InitRecPoints();
317 0 : }
318 0 : if(fSubDetector == 0 || fSubDetector == 3) {
319 0 : AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRecPoints\n");
320 0 : fSSDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
321 0 : fSSDDataMaker->InitRecPoints();
322 0 : }
323 :
324 0 : fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(20);
325 0 : if(fSubDetector == 0){
326 0 : Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
327 : const Bool_t expert = kTRUE ;
328 : const Bool_t image = kTRUE ;
329 0 : TH2F* hPhiEta[6];
330 0 : for (Int_t iLay=0;iLay<6;iLay++) {
331 0 : hPhiEta[iLay]=new TH2F(Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),30,-1.5,1.5,200,0.,2*TMath::Pi());
332 0 : hPhiEta[iLay]->GetXaxis()->SetTitle("Pseudorapidity");
333 0 : hPhiEta[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
334 0 : Add2RecPointsList(hPhiEta[iLay], iLay + offset, !expert, image);
335 : //delete hPhiEta[iLay];
336 : }
337 :
338 0 : }
339 : //
340 0 : ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
341 0 : }
342 :
343 : //____________________________________________________________________________
344 : void AliITSQADataMakerRec::MakeRecPoints(TTree * clustersTree)
345 : {
346 : // Fill QA for recpoints
347 :
348 0 : if(fSubDetector == 0 || fSubDetector == 1) {
349 0 : fSPDDataMaker->MakeRecPoints(clustersTree) ;
350 0 : }
351 :
352 0 : if(fSubDetector == 0 || fSubDetector == 2) {
353 0 : fSDDDataMaker->MakeRecPoints(clustersTree) ;
354 0 : }
355 :
356 0 : if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeRecPoints(clustersTree);
357 :
358 :
359 :
360 0 : if(fSubDetector == 0){
361 :
362 : // Check id histograms already created for this Event Specie
363 0 : AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
364 : TClonesArray *recpoints =NULL;
365 0 : if(fkOnline){
366 0 : rpcont->FetchClusters(0,clustersTree,GetEventNumber());
367 0 : }
368 : else{
369 0 : rpcont->FetchClusters(0,clustersTree);
370 : }
371 0 : if(!rpcont->GetStatusOK()){
372 0 : AliError("cannot access to ITS recpoints");
373 0 : return;
374 : }
375 :
376 0 : Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
377 0 : Float_t cluGlo[3] = {0.,0.,0.};
378 0 : Int_t lay, lad, det;
379 : // Fill QA for recpoints
380 0 : for(Int_t module=0; module<rpcont->GetNumberOfModules();module++){
381 : // AliInfo(Form("Module %d\n",module));
382 0 : recpoints = rpcont->UncheckedGetClusters(module);
383 0 : AliITSgeomTGeo::GetModuleId(module, lay, lad, det);
384 0 : for(Int_t j=0;j<recpoints->GetEntries();j++){
385 0 : AliITSRecPoint *rcp = (AliITSRecPoint*)recpoints->At(j);
386 : //Check id histograms already created for this Event Specie
387 0 : rcp->GetGlobalXYZ(cluGlo);
388 0 : Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]+cluGlo[2]*cluGlo[2]);
389 0 : Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
390 0 : Double_t theta = TMath::ACos(cluGlo[2]/rad);
391 : Double_t eta = 100.;
392 0 : if(AreEqual(rad,0.) == kFALSE) {
393 0 : if(theta<=1.e-14){ eta=30.; }
394 0 : else { eta = -TMath::Log(TMath::Tan(theta/2.));}
395 : }
396 : // printf("=========================>hlt rcp->GetLayer() = %d \n",rcp->GetLayer());
397 0 : FillRecPointsData(rcp->GetLayer() + offset - 6,eta,phi);
398 : }
399 : }
400 0 : }
401 : //
402 0 : IncEvCountCycleRecPoints();
403 0 : IncEvCountTotalRecPoints();
404 : //
405 0 : }
406 :
407 : //____________________________________________________________________________
408 : void AliITSQADataMakerRec::FillRecPoint(AliITSRecPoint rcp)
409 : {
410 :
411 : // Fill QA for recpoints
412 0 : Float_t cluGlo[3] = {0.,0.,0.};
413 0 : Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
414 : // Check id histograms already created for this Event Specie
415 0 : rcp.GetGlobalXYZ(cluGlo);
416 0 : Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]+cluGlo[2]*cluGlo[2]);
417 0 : Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
418 0 : Double_t theta = TMath::ACos(cluGlo[2]/rad);
419 : Double_t eta = 100.;
420 0 : if(AreEqual(rad,0.)==kFALSE) {
421 0 : if(theta<=1.e-14){eta=30.;}
422 0 : else {eta = -TMath::Log(TMath::Tan(theta/2.));}
423 : }
424 0 : FillRecPointsData( rcp.GetLayer() + offset - 6, eta,phi);
425 :
426 0 : }
427 :
428 : //____________________________________________________________________________
429 : TH2F *AliITSQADataMakerRec::GetITSGlobalHisto(Int_t layer)
430 : {
431 :
432 0 : Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
433 0 : return ((TH2F *) GetRecPointsData( layer + offset - 6));//local distribution
434 : }
435 :
436 : //____________________________________________________________________________
437 : void AliITSQADataMakerRec::InitESDs()
438 : {
439 :
440 : // Create ESDs histograms in ESDs subdir
441 :
442 : Bool_t expertHistogram = kTRUE;
443 :
444 : TH1F *hESDClustersMI =
445 0 : new TH1F("hESDClustersMI", "N ITS clusters per track (MI); N clusters; Counts",
446 : 7, -0.5, 6.5);
447 0 : hESDClustersMI->Sumw2();
448 0 : hESDClustersMI->SetMinimum(0);
449 0 : Add2ESDsList(hESDClustersMI, 0);
450 :
451 : TH1F *hESDClusterMapMI =
452 0 : new TH1F("hESDClusterMapMI", "N tracks with point Layer (MI); Layer; N tracks",
453 : 6, -0.5, 5.5);
454 0 : hESDClusterMapMI->Sumw2();
455 0 : hESDClusterMapMI->SetMinimum(0);
456 0 : Add2ESDsList(hESDClusterMapMI, 1, expertHistogram);
457 :
458 : TH1F *hESDClustersSA =
459 0 : new TH1F("hESDClustersSA", "N ITS clusters per track (SA); N clusters; Counts",
460 : 7, -0.5, 6.5);
461 0 : hESDClustersSA->Sumw2();
462 0 : hESDClustersSA->SetMinimum(0);
463 0 : Add2ESDsList(hESDClustersSA, 2);
464 :
465 : TH1F *hESDClusterMapSA =
466 0 : new TH1F("hESDClusterMapSA", "N tracks with point Layer (SA); Layer; N tracks",
467 : 6, -0.5, 5.5);
468 0 : hESDClusterMapSA->Sumw2();
469 0 : hESDClusterMapSA->SetMinimum(0);
470 0 : Add2ESDsList(hESDClusterMapSA, 3, expertHistogram);
471 :
472 : TH1F *hSPDVertexX =
473 0 : new TH1F("hSPDVertexX","SPD Vertex x; x [cm]; N events",
474 : 10000,-2,2);
475 0 : hSPDVertexX->Sumw2();
476 0 : Add2ESDsList(hSPDVertexX, 4);
477 :
478 : TH1F *hSPDVertexY =
479 0 : new TH1F("hSPDVertexY","SPD Vertex y; y [cm]; N events",
480 : 10000,-2,2);
481 0 : hSPDVertexY->Sumw2();
482 0 : Add2ESDsList(hSPDVertexY, 5);
483 :
484 : TH1F *hSPDVertexZ =
485 0 : new TH1F("hSPDVertexZ","SPD Vertex Z; z [cm]; N events",
486 : 10000,-20,20);
487 0 : hSPDVertexZ->Sumw2();
488 0 : Add2ESDsList(hSPDVertexZ, 6);
489 :
490 : TH1F *hSPDVertexContrOverMult =
491 0 : new TH1F("hSPDVertexContrOverMult","SPD Vertex: contributors / multiplicity; N contributors / SPD multiplicity; N events",
492 : 100,-4,20);
493 0 : hSPDVertexContrOverMult->Sumw2();
494 0 : Add2ESDsList(hSPDVertexContrOverMult, 7, expertHistogram);
495 :
496 : TH1F *hTrkVertexX =
497 0 : new TH1F("hTrkVertexX","ITS+TPC Trk Vertex x; x [cm]; N events",
498 : 10000,-2,2);
499 0 : hTrkVertexX->Sumw2();
500 0 : Add2ESDsList(hTrkVertexX, 8, expertHistogram);
501 :
502 : TH1F *hTrkVertexY =
503 0 : new TH1F("hTrkVertexY","ITS+TPC Trk Vertex y; y [cm]; N events",
504 : 10000,-2,2);
505 0 : hTrkVertexY->Sumw2();
506 0 : Add2ESDsList(hTrkVertexY, 9, expertHistogram);
507 :
508 : TH1F *hTrkVertexZ =
509 0 : new TH1F("hTrkVertexZ","ITS+TPC Trk Vertex Z; z [cm]; N events",
510 : 10000,-20,20);
511 0 : hTrkVertexZ->Sumw2();
512 0 : Add2ESDsList(hTrkVertexZ, 10, expertHistogram);
513 :
514 : TH1F *hTrkVertexContrOverITSrefit5 =
515 0 : new TH1F("hTrkVertexContrOverITSrefit5","ITS+TPC Trk Vertex: contributors / tracks; N contributors / N trks kITSrefit with 5 or 6 clusters; N events",
516 : 100,-4,2);
517 0 : hTrkVertexContrOverITSrefit5->Sumw2();
518 0 : Add2ESDsList(hTrkVertexContrOverITSrefit5, 11, expertHistogram);
519 :
520 : TH1F *hSPDTrkVertexDeltaX =
521 0 : new TH1F("hSPDTrkVertexDeltaX","Comparison of SPD and Trk vertices: x; xSPD-xTrk [cm]; N events",
522 : 1000,-1,1);
523 0 : hSPDTrkVertexDeltaX->Sumw2();
524 0 : Add2ESDsList(hSPDTrkVertexDeltaX, 12, expertHistogram);
525 :
526 : TH1F *hSPDTrkVertexDeltaY =
527 0 : new TH1F("hSPDTrkVertexDeltaY","Comparison of SPD and Trk vertices: y; ySPD-yTrk [cm]; N events",
528 : 1000,-1,1);
529 0 : hSPDTrkVertexDeltaY->Sumw2();
530 0 : Add2ESDsList(hSPDTrkVertexDeltaY, 13, expertHistogram);
531 :
532 : TH1F *hSPDTrkVertexDeltaZ =
533 0 : new TH1F("hSPDTrkVertexDeltaZ","Comparison of SPD and Trk vertices: z; zSPD-zTrk [cm]; N events",
534 : 1000,-1,1);
535 0 : hSPDTrkVertexDeltaZ->Sumw2();
536 0 : Add2ESDsList(hSPDTrkVertexDeltaZ, 14);
537 :
538 : // SPD Tracklets
539 :
540 : TH1F* hSPDTracklets =
541 0 : new TH1F("hSPDTracklets","N SPD Tracklets; N tracklets; Counts",300,0.,300.);
542 0 : hSPDTracklets->Sumw2();
543 0 : Add2ESDsList(hSPDTracklets, 15);
544 :
545 : TH2F* hSPDTrackletsvsFiredChips0 =
546 0 : new TH2F("hSPDTrackletsvsFiredChips0","N SPD Tracklets vs N FiredChips Layer0",
547 : 300,0.,300.,300,0.,300.);
548 0 : hSPDTrackletsvsFiredChips0->GetXaxis()->SetTitle("N FiredChips Layer0");
549 0 : hSPDTrackletsvsFiredChips0->GetYaxis()->SetTitle("N SPD Tracklets");
550 0 : hSPDTrackletsvsFiredChips0->Sumw2();
551 0 : Add2ESDsList(hSPDTrackletsvsFiredChips0, 16, expertHistogram );
552 :
553 : TH2F* hSPDTrackletsvsFiredChips1 =
554 0 : new TH2F("hSPDTrackletsvsFiredChips1","N SPD Tracklets vs N FiredChips Layer1",
555 : 300,0.,300.,300,0.,300.);
556 0 : hSPDTrackletsvsFiredChips1->GetXaxis()->SetTitle("N FiredChips Layer1");
557 0 : hSPDTrackletsvsFiredChips1->GetYaxis()->SetTitle("N SPD Tracklets");
558 0 : hSPDTrackletsvsFiredChips1->Sumw2();
559 0 : Add2ESDsList(hSPDTrackletsvsFiredChips1, 17, expertHistogram);
560 :
561 : TH2F* hSPDFiredChips1vsFiredChips0 =
562 0 : new TH2F("hSPDFiredChips1vsFiredChips0","N FiredChips Layer1 vs N FiredChips Layer0",
563 : 300,0.,300.,300,0.,300.);
564 0 : hSPDFiredChips1vsFiredChips0->GetXaxis()->SetTitle("N FiredChips Layer0");
565 0 : hSPDFiredChips1vsFiredChips0->GetYaxis()->SetTitle("N FiredChips Layer1");
566 0 : hSPDFiredChips1vsFiredChips0->Sumw2();
567 0 : Add2ESDsList(hSPDFiredChips1vsFiredChips0, 18, expertHistogram );
568 :
569 : TH1F* hSPDTrackletsDePhi =
570 0 : new TH1F("hSPDTrackletsDePhi","DeltaPhi SPD Tracklets; DeltaPhi [rad]; N events",200,-0.2,0.2);
571 0 : hSPDTrackletsDePhi->Sumw2();
572 0 : Add2ESDsList(hSPDTrackletsDePhi, 19);
573 :
574 : TH1F* hSPDTrackletsPhi =
575 0 : new TH1F("hSPDTrackletsPhi","Phi SPD Tracklets; Phi [rad]; N events",1000,0.,2*TMath::Pi());
576 0 : hSPDTrackletsPhi->Sumw2();
577 0 : Add2ESDsList(hSPDTrackletsPhi, 20);
578 :
579 : TH1F* hSPDTrackletsDeTheta =
580 0 : new TH1F("hSPDTrackletsDeTheta","DeltaTheta SPD Tracklets; DeltaTheta [rad]; N events",200,-0.2,0.2);
581 0 : hSPDTrackletsDeTheta->Sumw2();
582 0 : Add2ESDsList(hSPDTrackletsDeTheta, 21);
583 :
584 : TH1F* hSPDTrackletsTheta =
585 0 : new TH1F("hSPDTrackletsTheta","Theta SPD Tracklets; Theta [rad]; N events",500,0.,TMath::Pi());
586 0 : hSPDTrackletsTheta->Sumw2();
587 0 : Add2ESDsList(hSPDTrackletsTheta, 22);
588 :
589 : // map of layers skipped by tracking (set in AliITSRecoParam)
590 : TH1F *hESDSkippedLayers =
591 0 : new TH1F("hESDSkippedLayers", "Map of layers skipped by tracking; Layer; Skipped",
592 : 6, -0.5, 5.5);
593 0 : hESDSkippedLayers->Sumw2();
594 0 : hESDSkippedLayers->SetMinimum(0);
595 0 : Add2ESDsList(hESDSkippedLayers, 23, expertHistogram);
596 :
597 0 : fESDsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(30);
598 : //
599 0 : ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
600 0 : }
601 :
602 : //____________________________________________________________________________
603 : void AliITSQADataMakerRec::MakeESDs(AliESDEvent *esd)
604 : {
605 : // Make QA data from ESDs
606 :
607 : // Check id histograms already created for this Event Specie
608 : // if ( ! GetESDsData(0) )
609 : // InitESDs() ;
610 :
611 0 : const Int_t nESDTracks = esd->GetNumberOfTracks();
612 : Int_t nITSrefit5 = 0;
613 :
614 0 : Int_t idet,status;
615 0 : Float_t xloc,zloc;
616 :
617 : // loop on tracks
618 0 : AliInfo(Form("Filling histograms for ESD. Number of tracks %d",nESDTracks));
619 0 : for(Int_t i = 0; i < nESDTracks; i++) {
620 :
621 0 : AliESDtrack *track = esd->GetTrack(i);
622 :
623 0 : Int_t nclsITS = track->GetNcls(0);
624 :
625 : Bool_t itsrefit=kFALSE,tpcin=kFALSE,itsin=kFALSE;
626 0 : if ((track->GetStatus() & AliESDtrack::kITSrefit)) itsrefit=kTRUE;
627 0 : if ((track->GetStatus() & AliESDtrack::kTPCin)) tpcin=kTRUE;
628 0 : if ((track->GetStatus() & AliESDtrack::kITSin)) itsin=kTRUE;
629 0 : if(nclsITS>=5 && itsrefit) nITSrefit5++;
630 :
631 0 : if(tpcin) {
632 0 : FillESDsData(0,nclsITS);
633 0 : }
634 0 : if(itsin && !tpcin){
635 0 : FillESDsData(2,nclsITS);
636 0 : }
637 :
638 0 : for(Int_t layer=0; layer<6; layer++) {
639 :
640 0 : if(TESTBIT(track->GetITSClusterMap(),layer)) {
641 0 : if(tpcin) {
642 0 : FillESDsData(1,layer);
643 0 : } else {
644 0 : FillESDsData(3,layer);
645 : }
646 : }
647 0 : track->GetITSModuleIndexInfo(layer,idet,status,xloc,zloc);
648 0 : if(status==3) SetESDsDataBinContent(23,layer,1);
649 : }
650 :
651 : } // end loop on tracks
652 :
653 : // vertices
654 0 : const AliESDVertex *vtxSPD = esd->GetPrimaryVertexSPD();
655 0 : const AliESDVertex *vtxTrk = esd->GetPrimaryVertexTracks();
656 :
657 0 : Int_t mult = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfTracklets();
658 0 : AliInfo(Form("Multiplicity %d ; Number of SPD vert contributors %d",mult,vtxSPD->GetNContributors()));
659 0 : if(mult>0)
660 0 : FillESDsData(7,(Float_t)(vtxSPD->GetNContributors())/(Float_t)mult);
661 :
662 0 : if(nITSrefit5>0)
663 0 : FillESDsData(11,(Float_t)(vtxTrk->GetNIndices())/(Float_t)nITSrefit5);
664 :
665 0 : if(vtxSPD->GetNContributors()>0) {
666 0 : FillESDsData(4,vtxSPD->GetX());
667 0 : FillESDsData(5,vtxSPD->GetY());
668 0 : FillESDsData(6,vtxSPD->GetZ());
669 0 : }
670 :
671 0 : if(vtxTrk->GetNContributors()>0) {
672 0 : FillESDsData(8,vtxTrk->GetX());
673 0 : FillESDsData(9,vtxTrk->GetY());
674 0 : FillESDsData(10,vtxTrk->GetZ());
675 0 : }
676 :
677 0 : if(vtxSPD->GetNContributors()>0 &&
678 0 : vtxTrk->GetNContributors()>0) {
679 0 : FillESDsData(12,vtxSPD->GetX()-vtxTrk->GetX());
680 0 : FillESDsData(13,vtxSPD->GetY()-vtxTrk->GetY());
681 0 : FillESDsData(14,vtxSPD->GetZ()-vtxTrk->GetZ());
682 0 : }
683 :
684 : // SPD Tracklets
685 0 : FillESDsData(15,mult);
686 :
687 0 : Short_t nFiredChips0 = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfFiredChips(0);
688 0 : Short_t nFiredChips1 = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfFiredChips(1);
689 0 : FillESDsData(16,nFiredChips0,mult);
690 0 : FillESDsData(17,nFiredChips1,mult);
691 0 : FillESDsData(18,nFiredChips0,nFiredChips1);
692 :
693 : // Loop over tracklets
694 0 : for (Int_t itr=0; itr<mult; ++itr) {
695 0 : Float_t dePhiTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetDeltaPhi(itr);
696 0 : Float_t deThetaTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetDeltaTheta(itr);
697 0 : Float_t phiTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetPhi(itr);
698 0 : Float_t thetaTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetTheta(itr);
699 0 : FillESDsData(19,dePhiTr);
700 0 : FillESDsData(20,phiTr);
701 0 : FillESDsData(21,deThetaTr);
702 0 : FillESDsData(22,thetaTr);
703 : } // end loop on tracklets
704 : //
705 0 : IncEvCountCycleESDs();
706 0 : IncEvCountTotalESDs();
707 : //
708 0 : }
709 :
710 : //_________________________________________________________________
711 : Int_t AliITSQADataMakerRec::GetDetTaskOffset(Int_t subdet,AliQAv1::TASKINDEX_t task, Int_t specie)
712 : {
713 : //number of booked histos for the QAchecking Raws offset
714 : Int_t offset=0;
715 0 : switch(subdet)
716 : {
717 : case 1:
718 0 : offset=fSPDDataMaker->GetOffset(task,specie);
719 : //return offset;
720 0 : break;
721 : case 2:
722 0 : offset=fSDDDataMaker->GetOffset(task,specie);
723 : //return offset;
724 0 : break;
725 : case 3:
726 0 : offset=fSSDDataMaker->GetOffset(task,specie);
727 : //return offset;
728 0 : break;
729 : default:
730 0 : AliWarning("No specific subdetector (SPD, SDD, SSD) selected!! Offset set to zero \n");
731 : offset=0;
732 : //return offset;
733 0 : break;
734 : }
735 0 : return offset;
736 : }
737 :
738 : //____________________________________________________________________
739 :
740 : Bool_t AliITSQADataMakerRec::AreEqual(Double_t a1,Double_t a2)
741 : {
742 : const Double_t kEpsilon= 1.e-14;
743 0 : return TMath::Abs(a1-a2)<=kEpsilon*TMath::Abs(a1);
744 : }
745 :
746 : //_________________________________________________________________
747 : Int_t AliITSQADataMakerRec::GetDetTaskHisto(Int_t subdet,AliQAv1::TASKINDEX_t task)
748 : {
749 : //return the number of histo booked for each the Raws Task
750 :
751 : Int_t histo=0;
752 0 : switch(subdet)
753 : {
754 : case 1:
755 0 : histo=fSPDDataMaker->GetTaskHisto(task);
756 : //return histo;
757 0 : break;
758 : case 2:
759 0 : histo=fSDDDataMaker->GetTaskHisto(task);
760 : //return histo;
761 0 : break;
762 : case 3:
763 0 : histo=fSSDDataMaker->GetTaskHisto(task);
764 : //return histo;
765 0 : break;
766 : default:
767 0 : AliWarning("No specific subdetector (SPD, SDD, SSD) selected!! Offset set to zero \n");
768 : histo=0;
769 : //return histo;
770 0 : break;
771 : }
772 : //return offset;
773 0 : return histo;
774 : }
775 :
776 :
777 : //____________________________________________________________________
778 :
779 : void AliITSQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
780 : {
781 : //reset the detector histograms for a given task
782 0 : AliQADataMakerRec::ResetDetector(task);
783 :
784 0 : if(fSubDetector==0||fSubDetector==1)fSPDDataMaker->ResetDetector(task);
785 :
786 0 : if(fSubDetector==0||fSubDetector==2)fSDDDataMaker->ResetDetector(task);
787 :
788 0 : if(fSubDetector==0||fSubDetector==3)fSSDDataMaker->ResetDetector(task);
789 :
790 0 : }
791 :
792 :
793 : //____________________________________________________________________
794 :
795 : AliITSDDLModuleMapSDD *AliITSQADataMakerRec::GetDDLSDDModuleMap()
796 : {
797 : //return the SDD module map
798 0 : if(fSubDetector==2){return fSDDDataMaker->GetDDLSDDModuleMap();}
799 0 : else {return NULL;}
800 0 : }
801 :
802 : //____________________________________________________________________
803 : Bool_t AliITSQADataMakerRec::ListExists(AliQAv1::TASKINDEX_t task) const
804 : {
805 : //Check the existence of a list for a given task
806 : Bool_t havethelist=kFALSE;
807 0 : if( ( task == AliQAv1::kRAWS && fRawsQAList ) ||
808 0 : ( task == AliQAv1::kRECPOINTS && fRecPointsQAList ) ||
809 0 : ( task == AliQAv1::kDIGITSR && fDigitsQAList ) ||
810 0 : ( task == AliQAv1::kESDS && fESDsQAList ) ) havethelist=kTRUE;
811 0 : return havethelist;
812 :
813 : }
|
