2 //**************************************************************************
3 //* This file is property of and copyright by the ALICE HLT Project *
4 //* ALICE Experiment at CERN, All rights reserved. *
6 //* Primary Authors: Ingrid Kielen *
7 //* for The ALICE HLT Project. *
9 //* Permission to use, copy, modify and distribute this software and its *
10 //* documentation strictly for non-commercial purposes is hereby granted *
11 //* without fee, provided that the above copyright notice appears in all *
12 //* copies and that both the copyright notice and this permission notice *
13 //* appear in the supporting documentation. The authors make no claims *
14 //* about the suitability of this software for any purpose. It is *
15 //* provided "as is" without express or implied warranty. *
16 //**************************************************************************
18 /** @file AliHLTITSSSDQARecPointsComponent.cxx
19 @author Ingrid Kielen - Panos Christakoglou (Panos.Christakoglou@cern.ch)
20 @brief Component for the SSD clusters QA
23 #include "AliHLTITSSSDQARecPointsComponent.h"
24 #include "AliHLTITSClusterDataFormat.h"
25 #include "AliCDBEntry.h"
26 #include "AliCDBManager.h"
27 #include "AliITSRecPoint.h"
31 #include "TObjString.h"
32 #include "TObjArray.h"
35 #include "AliITSgeomTGeo.h"
36 #include "AliGeomManager.h"
43 /** ROOT macro for the implementation of ROOT specific class methods */
44 ClassImp(AliHLTITSSSDQARecPointsComponent)
46 AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent()
49 // see header file for class documentation
51 // refer to README to build package
53 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
57 AliHLTITSSSDQARecPointsComponent::~AliHLTITSSSDQARecPointsComponent()
59 // see header file for class documentation
62 // Public functions to implement AliHLTComponent's interface.
63 // These functions are required for the registration process
65 const char* AliHLTITSSSDQARecPointsComponent::GetComponentID()
67 // see header file for class documentation
69 return "ITSSSDQARecPoints";
72 void AliHLTITSSSDQARecPointsComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
73 // see header file for class documentation
75 list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
78 AliHLTComponentDataType AliHLTITSSSDQARecPointsComponent::GetOutputDataType() {
79 // see header file for class documentation
80 return kAliHLTDataTypeTObjArray;
83 void AliHLTITSSSDQARecPointsComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
85 // see header file for class documentation
86 // XXX TODO: Find more realistic values.
91 AliHLTComponent* AliHLTITSSSDQARecPointsComponent::Spawn()
93 // see header file for class documentation
94 return new AliHLTITSSSDQARecPointsComponent;
97 int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) {
98 //Inititalization of histograms for the SSD QA component
101 if(AliGeomManager::GetGeometry()==NULL){
102 AliGeomManager::LoadGeometry();
106 fHistSSDArray = new TObjArray();
107 fHistSSDArray->SetName("ssdArray");
109 Int_t nModuleOffset = 500;
110 Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
111 TH1F *gHistSSDModuleIdLayer5 = new TH1F("fHistSSDModuleIdLayer5",
112 "Module Id - Layer 5;Module Id;Entries",
115 nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
116 fHistSSDArray->Add(gHistSSDModuleIdLayer5);//entry 0
118 TH1F *gHistSSDModuleIdLayer6 = new TH1F("fHistSSDModuleIdLayer6",
119 "Module Id - Layer 6;Module Id;Entries",
121 nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
122 nITSTotalModules + 0.5);
123 fHistSSDArray->Add(gHistSSDModuleIdLayer6);//entry 1
125 TH1F *gHistSSDClusterPerEventLayer5 = new TH1F("fHistSSDClusterPerEventLayer5",
126 "N_{clusters} - Layer 5;N_{clusters};Entries;",
128 fHistSSDArray->Add(gHistSSDClusterPerEventLayer5);//entry 2
130 TH1F *gHistSSDClusterPerEventLayer6 = new TH1F("fHistSSDClusterPerEventLayer6",
131 "N_{clusters} - Layer 6;N_{clusters};Entries;",
133 fHistSSDArray->Add(gHistSSDClusterPerEventLayer6);//entry 3
135 TH1F *gHistSSDLocalXLayer5 = new TH1F("fHistSSDLocalXLayer5",
136 "Local x coord.- Layer 5;x [cm];Entries;",
138 fHistSSDArray->Add(gHistSSDLocalXLayer5);//entry 4
140 TH1F *gHistSSDLocalXLayer6 = new TH1F("fHistSSDLocalXLayer6",
141 "Local x coord.- Layer 6;x [cm];Entries;",
143 fHistSSDArray->Add(gHistSSDLocalXLayer6);//entry 5
145 TH1F *gHistSSDLocalZLayer5 = new TH1F("fHistSSDLocalZLayer5",
146 "Local z coord.- Layer 5;z [cm];Entries;",
148 fHistSSDArray->Add(gHistSSDLocalZLayer5);//entry 6
150 TH1F *gHistSSDLocalZLayer6 = new TH1F("fHistSSDLocalZLayer6",
151 "Local z coord.- Layer 6;z [cm];Entries;",
153 fHistSSDArray->Add(gHistSSDLocalZLayer6);//entry 7
155 TH1F *gHistSSDGlobalXLayer5 = new TH1F("fHistSSDGlobalXLayer5",
156 "Global x - Layer 5;x [cm];Entries;",
158 fHistSSDArray->Add(gHistSSDGlobalXLayer5);//entry 8
160 TH1F *gHistSSDGlobalXLayer6 = new TH1F("fHistSSDGlobalXLayer6",
161 "Global x - Layer 6;x [cm];Entries;",
163 fHistSSDArray->Add(gHistSSDGlobalXLayer6);//entry 9
165 TH1F *gHistSSDGlobalYLayer5 = new TH1F("fHistSSDGlobalYLayer5",
166 "Global y - Layer 5;y [cm];Entries;",
168 fHistSSDArray->Add(gHistSSDGlobalYLayer5);//entry 10
170 TH1F *gHistSSDGlobalYLayer6 = new TH1F("fHistSSDGlobalYLayer6",
171 "Global y - Layer 6;y [cm];Entries;",
173 fHistSSDArray->Add(gHistSSDGlobalYLayer6);//entry 11
175 TH1F *gHistSSDGlobalZLayer5 = new TH1F("fHistSSDGlobalZLayer5",
176 "Global z - Layer 5;z [cm];Entries;",
178 fHistSSDArray->Add(gHistSSDGlobalZLayer5);//entry 12
180 TH1F *gHistSSDGlobalZLayer6 = new TH1F("fHistSSDGlobalZLayer6",
181 "Global z - Layer 6;z [cm];Entries;",
183 fHistSSDArray->Add(gHistSSDGlobalZLayer6);//entry 13
185 TH1F *gHistSSDPhiLayer5 = new TH1F("fHistSSDPhiLayer5",
186 "#phi - Layer 5;#phi [rad];Entries;",
187 100,-TMath::Pi(),TMath::Pi());
188 fHistSSDArray->Add(gHistSSDPhiLayer5);//entry 14
190 TH1F *gHistSSDPhiLayer6 = new TH1F("fHistSSDPhiLayer6",
191 "#phi - Layer 6;#phi [rad];Entries;",
192 100,-TMath::Pi(),TMath::Pi());
193 fHistSSDArray->Add(gHistSSDPhiLayer6);//entry 15
195 TH1F *gHistSSDThetaLayer5 = new TH1F("fHistSSDThetaLayer5",
196 "#theta - Layer 5;#theta [rad];Entries;",
197 100,-TMath::Pi(),TMath::Pi());
198 fHistSSDArray->Add(gHistSSDThetaLayer5);//entry 16
200 TH1F *gHistSSDThetaLayer6 = new TH1F("fHistSSDThetaLayer6",
201 "#theta - Layer 6;#theta [rad];Entries;",
202 100,-TMath::Pi(),TMath::Pi());
203 fHistSSDArray->Add(gHistSSDThetaLayer6);//entry 17
205 TH1F *gHistSSDRadiusLayer5 = new TH1F("fHistSSDRadiusLayer5",
206 "r - Layer 5;r [cm];Entries;",
208 fHistSSDArray->Add(gHistSSDRadiusLayer5);//entry 18
210 TH1F *gHistSSDRadiusLayer6 = new TH1F("fHistSSDRadiusLayer6",
211 "r - Layer 6;r [cm];Entries;",
213 fHistSSDArray->Add(gHistSSDRadiusLayer6);//entry 19
215 TH1F *gHistSSDClusterTypeLayer5 = new TH1F("Layer5/fHistSSDClusterTypeLayer5",
216 "CL type - Layer 5;Cluster type;Entries;",
218 fHistSSDArray->Add(gHistSSDClusterTypeLayer5);//entry 20
220 TH1F *gHistSSDClusterTypeLayer6 = new TH1F("fHistSSDClusterTypeLayer6",
221 "CL type - Layer 6;Cluster type;Entries;",
223 fHistSSDArray->Add(gHistSSDClusterTypeLayer6);//entry 21
225 TH1F *gHistSSDChargeRatioLayer5 = new TH1F("fHistSSDChargeRatioLayer5",
226 "Charge ratio - Layer 5;q_{ratio};Entries;",
228 fHistSSDArray->Add(gHistSSDChargeRatioLayer5);//entry 22
230 TH1F *gHistSSDChargeRatioLayer6 = new TH1F("fHistSSDChargeRatioLayer6",
231 "Charge ratio - Layer 6;q_{ratio};Entries;",
233 fHistSSDArray->Add(gHistSSDChargeRatioLayer6);//entry 23
235 TH1F *gHistSSDChargekeVLayer5 = new TH1F("fHistSSDChargekeVLayer5",
236 "Charge - Layer 5;q [keV];Entries;",
238 fHistSSDArray->Add(gHistSSDChargekeVLayer5);//entry 24
240 TH1F *gHistSSDChargekeVLayer6 = new TH1F("fHistSSDChargekeVLayer6",
241 "Charge - Layer 6;q [keV];Entries;",
243 fHistSSDArray->Add(gHistSSDChargekeVLayer6);//entry 25
245 TH1F *gHistSSDChargePSideLayer5 = new TH1F("fHistSSDChargePSideLayer5",
246 "Charge P- Layer 5;q_{P} [keV];Entries;",
248 fHistSSDArray->Add(gHistSSDChargePSideLayer5);//entry 26
250 TH1F *gHistSSDChargePSideLayer6 = new TH1F("fHistSSDChargePSideLayer6",
251 "Charge P- Layer 6;q_{P} [keV];Entries;",
253 fHistSSDArray->Add(gHistSSDChargePSideLayer6);//entry 27
255 TH1F *gHistSSDChargeNSideLayer5 = new TH1F("fHistSSDChargeNSideLayer5",
256 "Charge N- Layer 5;q_{N} [keV];Entries;",
258 fHistSSDArray->Add(gHistSSDChargeNSideLayer5);//entry 28
260 TH1F *gHistSSDChargeNSideLayer6 = new TH1F("fHistSSDChargeNSideLayer6",
261 "Charge N- Layer 6;q_{N} [keV];Entries;",
263 fHistSSDArray->Add(gHistSSDChargeNSideLayer6);//entry 29
265 TH1F *gHistSSDChargeRatio2Layer5 = new TH1F("fHistSSDChargeRatio2Layer5",
266 "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
268 fHistSSDArray->Add(gHistSSDChargeRatio2Layer5);//entry 30
270 TH1F *gHistSSDChargeRatio2Layer6 = new TH1F("fHistSSDChargeRatio2Layer6",
271 "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
273 fHistSSDArray->Add(gHistSSDChargeRatio2Layer6);//entry 31
275 TH2F *gHistSSDChargePNSideLayer5 = new TH2F("fHistSSDChargePNSideLayer5",
276 "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
279 fHistSSDArray->Add(gHistSSDChargePNSideLayer5);//entry 32
281 TH2F *gHistSSDChargePNSideLayer6 = new TH2F("fHistSSDChargePNSideLayer6",
282 "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
285 fHistSSDArray->Add(gHistSSDChargePNSideLayer6);//entry 33
287 TH2F *gHistSSDChargeMapLayer5 = new TH2F("fHistSSDChargeMapLayer5",
288 "Charge map;N_{modules};N_{Ladders}",
289 fgkSSDMODULESPERLADDERLAYER5,
290 -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,
291 3*fgkSSDLADDERSLAYER5,
292 -0.5,fgkSSDLADDERSLAYER5+0.5);
293 fHistSSDArray->Add(gHistSSDChargeMapLayer5);//entry 34
295 TH2F *gHistSSDChargeMapLayer6 = new TH2F("fHistSSDChargeMapLayer6",
296 "Charge map;N_{modules};N_{Ladders}",
297 fgkSSDMODULESPERLADDERLAYER6,
298 -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,
299 3*fgkSSDLADDERSLAYER6,
300 -0.5,fgkSSDLADDERSLAYER6+0.5);
301 fHistSSDArray->Add(gHistSSDChargeMapLayer6);//entry 35
303 TH2F *gHistSSDClusterMapLayer5 = new TH2F("fHistSSDClusterMapLayer5",
304 "Layer 5;N_{module};N_{ladder}",
307 gHistSSDClusterMapLayer5->GetXaxis()->SetTitleColor(1);
308 gHistSSDClusterMapLayer5->SetStats(kFALSE);
309 gHistSSDClusterMapLayer5->GetYaxis()->SetTitleOffset(1.8);
310 gHistSSDClusterMapLayer5->GetXaxis()->SetNdivisions(22);
311 gHistSSDClusterMapLayer5->GetYaxis()->SetNdivisions(34);
312 gHistSSDClusterMapLayer5->GetXaxis()->SetLabelSize(0.03);
313 gHistSSDClusterMapLayer5->GetYaxis()->SetLabelSize(0.03);
314 gHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
315 gHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
316 fHistSSDArray->Add(gHistSSDClusterMapLayer5); //entry 36
318 TH2F *gHistSSDClusterMapLayer6 = new TH2F("fHistSSDClusterMapLayer6",
319 "Layer 6;N_{module};N_{ladder}",
322 gHistSSDClusterMapLayer6->GetXaxis()->SetTitleColor(1);
323 gHistSSDClusterMapLayer6->SetStats(kFALSE);
324 gHistSSDClusterMapLayer6->GetYaxis()->SetTitleOffset(1.8);
325 gHistSSDClusterMapLayer6->GetXaxis()->SetNdivisions(25);
326 gHistSSDClusterMapLayer6->GetYaxis()->SetNdivisions(38);
327 gHistSSDClusterMapLayer6->GetXaxis()->SetLabelSize(0.03);
328 gHistSSDClusterMapLayer6->GetYaxis()->SetLabelSize(0.03);
329 gHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
330 gHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
331 fHistSSDArray->Add(gHistSSDClusterMapLayer6);//entry 37
333 HLTInfo("Finished initialization of SSD histograms");
338 int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
339 // see header file for class documentation
340 if(fHistSSDArray) delete fHistSSDArray;
345 int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
348 Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;
350 const AliHLTComponentBlockData* iter = NULL;
355 for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
357 if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD))
360 const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
361 Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
362 AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints;
364 for(int i = 0; i < nSpacepoint; i++) { //cluster loop
365 Int_t lab[4]={0,0,0,0};
366 Float_t hit[6]={0,0,0,0,0,0};
367 Int_t info[3]={0,0,0};
369 lab[0]=clusters[i].fTracks[0];
370 lab[1]=clusters[i].fTracks[1];
371 lab[2]=clusters[i].fTracks[2];
372 lab[3]=clusters[i].fIndex;
373 hit[0]=clusters[i].fY;
374 hit[1]=clusters[i].fZ;
375 hit[2]=clusters[i].fSigmaY2;
376 hit[3]=clusters[i].fSigmaZ2;
377 hit[4]=clusters[i].fQ;
378 hit[5]=clusters[i].fSigmaYZ;
379 info[0]=clusters[i].fNy;
380 info[1]=clusters[i].fNz;
381 info[2]=clusters[i].fLayer;
383 AliITSRecPoint recp(lab,hit,info);
386 Int_t gLayer = 0, gLadder = 0, gModule = 0;
387 Int_t lLadderLocationY = 0;
389 Float_t cluglo[3]={0.,0.,0.};
391 Int_t layer = recp.GetLayer();
392 if (layer == 4) module = recp.GetDetectorIndex() + 500;
393 if (layer == 5) module = recp.GetDetectorIndex() + 1248;
395 AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);
396 lLadderLocationY = 3*gLadder;
398 recp.GetGlobalXYZ(cluglo);
399 Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]);
400 Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);
401 Float_t theta = TMath::ATan2(radius,cluglo[2]);
402 Double_t chargeRatio = recp.GetChargeRatio();
403 Double_t clusterCharge = recp.GetQ();
404 Double_t chargePSide = clusterCharge*(1. + chargeRatio);
405 Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
408 dynamic_cast<TH1F *>(fHistSSDArray->At(0))->Fill(module);
409 dynamic_cast<TH1F *>(fHistSSDArray->At(4))->Fill(recp.GetDetLocalX());
410 dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
411 dynamic_cast<TH1F *>(fHistSSDArray->At(8))->Fill(cluglo[0]);
412 dynamic_cast<TH1F *>(fHistSSDArray->At(10))->Fill(cluglo[1]);
413 dynamic_cast<TH1F *>(fHistSSDArray->At(12))->Fill(cluglo[2]);
414 dynamic_cast<TH1F *>(fHistSSDArray->At(14))->Fill(phi);
415 dynamic_cast<TH1F *>(fHistSSDArray->At(16))->Fill(theta);
416 dynamic_cast<TH1F *>(fHistSSDArray->At(18))->Fill(radius);
417 dynamic_cast<TH1F *>(fHistSSDArray->At(20))->Fill(recp.GetType());
418 dynamic_cast<TH1F *>(fHistSSDArray->At(22))->Fill(recp.GetChargeRatio());
419 dynamic_cast<TH1F *>(fHistSSDArray->At(24))->Fill(recp.GetQ());
420 dynamic_cast<TH1F *>(fHistSSDArray->At(26))->Fill(chargePSide);
421 dynamic_cast<TH1F *>(fHistSSDArray->At(28))->Fill(chargeNSide);
422 if(chargePSide != 0.)
423 dynamic_cast<TH1F *>(fHistSSDArray->At(30))->Fill(chargeNSide/chargePSide);
424 dynamic_cast<TH2F *>(fHistSSDArray->At(32))->Fill(chargePSide,
426 dynamic_cast<TH2F *>(fHistSSDArray->At(34))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
427 dynamic_cast<TH2F *>(fHistSSDArray->At(36))->Fill(gModule,499+gLadder,1);
428 nClustersLayer5 += 1;
429 }//layer 5 histograms
431 dynamic_cast<TH1F *>(fHistSSDArray->At(1))->Fill(module);
432 dynamic_cast<TH1F *>(fHistSSDArray->At(5))->Fill(recp.GetDetLocalX());
433 dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
434 dynamic_cast<TH1F *>(fHistSSDArray->At(9))->Fill(cluglo[0]);
435 dynamic_cast<TH1F *>(fHistSSDArray->At(11))->Fill(cluglo[1]);
436 dynamic_cast<TH1F *>(fHistSSDArray->At(13))->Fill(cluglo[2]);
437 dynamic_cast<TH1F *>(fHistSSDArray->At(15))->Fill(phi);
438 dynamic_cast<TH1F *>(fHistSSDArray->At(17))->Fill(theta);
439 dynamic_cast<TH1F *>(fHistSSDArray->At(19))->Fill(radius);
440 dynamic_cast<TH1F *>(fHistSSDArray->At(21))->Fill(recp.GetType());
441 dynamic_cast<TH1F *>(fHistSSDArray->At(23))->Fill(recp.GetChargeRatio());
442 dynamic_cast<TH1F *>(fHistSSDArray->At(25))->Fill(recp.GetQ());
443 dynamic_cast<TH1F *>(fHistSSDArray->At(27))->Fill(chargePSide);
444 dynamic_cast<TH1F *>(fHistSSDArray->At(29))->Fill(chargeNSide);
445 if(chargePSide != 0.)
446 dynamic_cast<TH1F *>(fHistSSDArray->At(31))->Fill(chargeNSide/chargePSide);
447 dynamic_cast<TH2F *>(fHistSSDArray->At(33))->Fill(chargePSide,
449 dynamic_cast<TH2F *>(fHistSSDArray->At(35))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
450 dynamic_cast<TH2F *>(fHistSSDArray->At(37))->Fill(gModule,599+gLadder,1);
451 nClustersLayer6 += 1;
452 }//layer 6 histograms
454 dynamic_cast<TH1F *>(fHistSSDArray->At(2))->Fill(nClustersLayer5);
455 dynamic_cast<TH1F *>(fHistSSDArray->At(3))->Fill(nClustersLayer6);
459 AliHLTUInt32_t fSpecification = 0x0;
460 PushBack( (TObjArray*) fHistSSDArray,kAliHLTDataTypeTObjArray|kAliHLTDataOriginITSSSD,fSpecification);
462 HLTInfo("ITSSSDQARecPoints found %d SSD clusters", nClustersLayer5+nClustersLayer6);