adding map include file to solve compilation issue (bug https://savannah.cern.ch...
[u/mrichter/AliRoot.git] / HLT / ITS / AliHLTITSSSDQARecPointsComponent.cxx
CommitLineData
fd091d74 1// $Id$
2//**************************************************************************
3//* This file is property of and copyright by the ALICE HLT Project *
4//* ALICE Experiment at CERN, All rights reserved. *
5//* *
6//* Primary Authors: Ingrid Kielen *
7//* for The ALICE HLT Project. *
8//* *
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//**************************************************************************
17
18/** @file AliHLTITSSSDQARecPointsComponent.cxx
4b1ad1e4 19 @author Ingrid Kielen - Panos Christakoglou (Panos.Christakoglou@cern.ch)
fd091d74 20 @brief Component for the SSD clusters QA
21*/
22
23#if __GNUC__>= 3
24using namespace std;
25#endif
26
27#include "AliHLTITSSSDQARecPointsComponent.h"
28#include "AliHLTITSClusterDataFormat.h"
29#include "AliCDBEntry.h"
30#include "AliCDBManager.h"
31#include "AliITSRecPoint.h"
32#include <TFile.h>
33#include <TMath.h>
34#include <TString.h>
35#include "TObjString.h"
36#include "TObjArray.h"
4b1ad1e4 37#include "TH1.h"
38#include "TH2.h"
fd091d74 39#include "AliITSgeomTGeo.h"
b5284ba2 40#include "AliGeomManager.h"
fd091d74 41
42//#include <stdlib.h>
43//#include <cerrno>
44
45/** ROOT macro for the implementation of ROOT specific class methods */
46ClassImp(AliHLTITSSSDQARecPointsComponent)
47
48AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent()
49 :AliHLTProcessor(),
4b1ad1e4 50 fHistSSDArray(NULL) {
fd091d74 51 // see header file for class documentation
52 // or
53 // refer to README to build package
54 // or
55 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
56
57}
58
59AliHLTITSSSDQARecPointsComponent::~AliHLTITSSSDQARecPointsComponent()
60{
61 // see header file for class documentation
62}
63
64// Public functions to implement AliHLTComponent's interface.
65// These functions are required for the registration process
66
67const char* AliHLTITSSSDQARecPointsComponent::GetComponentID()
68{
69 // see header file for class documentation
70
71 return "ITSSSDQARecPoints";
72}
73
74void AliHLTITSSSDQARecPointsComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
75 // see header file for class documentation
76 list.clear();
77 list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
78}
79
80AliHLTComponentDataType AliHLTITSSSDQARecPointsComponent::GetOutputDataType() {
81 // see header file for class documentation
82 return kAliHLTDataTypeTObjArray;
83}
84
85void AliHLTITSSSDQARecPointsComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
86{
87 // see header file for class documentation
88 // XXX TODO: Find more realistic values.
89 constBase = 80000;
90 inputMultiplier = 10;
91}
92
93AliHLTComponent* AliHLTITSSSDQARecPointsComponent::Spawn()
94{
95 // see header file for class documentation
96 return new AliHLTITSSSDQARecPointsComponent;
97}
98
4b1ad1e4 99int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) {
fd091d74 100 //Inititalization of histograms for the SSD QA component
b5284ba2 101
102
103 if(AliGeomManager::GetGeometry()==NULL){
104 AliGeomManager::LoadGeometry();
105 }
106
107
4b1ad1e4 108 fHistSSDArray = new TObjArray();
109 fHistSSDArray->SetName("ssdArray");
fd091d74 110
111 Int_t nModuleOffset = 500;
112 Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
4b1ad1e4 113 TH1F *gHistSSDModuleIdLayer5 = new TH1F("fHistSSDModuleIdLayer5",
114 "Module Id - Layer 5;Module Id;Entries",
115 fgkSSDMODULESLAYER5,
116 nModuleOffset - 0.5,
117 nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
118 fHistSSDArray->Add(gHistSSDModuleIdLayer5);//entry 0
119
120 TH1F *gHistSSDModuleIdLayer6 = new TH1F("fHistSSDModuleIdLayer6",
121 "Module Id - Layer 6;Module Id;Entries",
122 fgkSSDMODULESLAYER6,
123 nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
124 nITSTotalModules + 0.5);
125 fHistSSDArray->Add(gHistSSDModuleIdLayer6);//entry 1
126
127 TH1F *gHistSSDClusterPerEventLayer5 = new TH1F("fHistSSDClusterPerEventLayer5",
128 "N_{clusters} - Layer 5;N_{clusters};Entries;",
129 100,0.1,5000);
130 fHistSSDArray->Add(gHistSSDClusterPerEventLayer5);//entry 2
131
132 TH1F *gHistSSDClusterPerEventLayer6 = new TH1F("fHistSSDClusterPerEventLayer6",
133 "N_{clusters} - Layer 6;N_{clusters};Entries;",
134 100,0.1,5000);
135 fHistSSDArray->Add(gHistSSDClusterPerEventLayer6);//entry 3
136
137 TH1F *gHistSSDLocalXLayer5 = new TH1F("fHistSSDLocalXLayer5",
138 "Local x coord.- Layer 5;x [cm];Entries;",
139 100,-4.,4.);
140 fHistSSDArray->Add(gHistSSDLocalXLayer5);//entry 4
141
142 TH1F *gHistSSDLocalXLayer6 = new TH1F("fHistSSDLocalXLayer6",
143 "Local x coord.- Layer 6;x [cm];Entries;",
144 100,-4.,4.);
145 fHistSSDArray->Add(gHistSSDLocalXLayer6);//entry 5
146
147 TH1F *gHistSSDLocalZLayer5 = new TH1F("fHistSSDLocalZLayer5",
148 "Local z coord.- Layer 5;z [cm];Entries;",
149 100,-4.,4.);
150 fHistSSDArray->Add(gHistSSDLocalZLayer5);//entry 6
151
152 TH1F *gHistSSDLocalZLayer6 = new TH1F("fHistSSDLocalZLayer6",
153 "Local z coord.- Layer 6;z [cm];Entries;",
154 100,-4.,4.);
155 fHistSSDArray->Add(gHistSSDLocalZLayer6);//entry 7
156
157 TH1F *gHistSSDGlobalXLayer5 = new TH1F("fHistSSDGlobalXLayer5",
158 "Global x - Layer 5;x [cm];Entries;",
159 100,-40.,40.);
160 fHistSSDArray->Add(gHistSSDGlobalXLayer5);//entry 8
161
162 TH1F *gHistSSDGlobalXLayer6 = new TH1F("fHistSSDGlobalXLayer6",
163 "Global x - Layer 6;x [cm];Entries;",
164 100,-45.,45.);
165 fHistSSDArray->Add(gHistSSDGlobalXLayer6);//entry 9
166
167 TH1F *gHistSSDGlobalYLayer5 = new TH1F("fHistSSDGlobalYLayer5",
168 "Global y - Layer 5;y [cm];Entries;",
169 100,-40.,40);
170 fHistSSDArray->Add(gHistSSDGlobalYLayer5);//entry 10
171
172 TH1F *gHistSSDGlobalYLayer6 = new TH1F("fHistSSDGlobalYLayer6",
173 "Global y - Layer 6;y [cm];Entries;",
174 100,-45.,45.);
175 fHistSSDArray->Add(gHistSSDGlobalYLayer6);//entry 11
176
177 TH1F *gHistSSDGlobalZLayer5 = new TH1F("fHistSSDGlobalZLayer5",
178 "Global z - Layer 5;z [cm];Entries;",
179 100,-45.,45);
180 fHistSSDArray->Add(gHistSSDGlobalZLayer5);//entry 12
181
182 TH1F *gHistSSDGlobalZLayer6 = new TH1F("fHistSSDGlobalZLayer6",
183 "Global z - Layer 6;z [cm];Entries;",
184 100,-55.,55.);
185 fHistSSDArray->Add(gHistSSDGlobalZLayer6);//entry 13
186
187 TH1F *gHistSSDPhiLayer5 = new TH1F("fHistSSDPhiLayer5",
188 "#phi - Layer 5;#phi [rad];Entries;",
189 100,-TMath::Pi(),TMath::Pi());
190 fHistSSDArray->Add(gHistSSDPhiLayer5);//entry 14
191
192 TH1F *gHistSSDPhiLayer6 = new TH1F("fHistSSDPhiLayer6",
193 "#phi - Layer 6;#phi [rad];Entries;",
194 100,-TMath::Pi(),TMath::Pi());
195 fHistSSDArray->Add(gHistSSDPhiLayer6);//entry 15
196
197 TH1F *gHistSSDThetaLayer5 = new TH1F("fHistSSDThetaLayer5",
198 "#theta - Layer 5;#theta [rad];Entries;",
199 100,-TMath::Pi(),TMath::Pi());
200 fHistSSDArray->Add(gHistSSDThetaLayer5);//entry 16
201
202 TH1F *gHistSSDThetaLayer6 = new TH1F("fHistSSDThetaLayer6",
203 "#theta - Layer 6;#theta [rad];Entries;",
204 100,-TMath::Pi(),TMath::Pi());
205 fHistSSDArray->Add(gHistSSDThetaLayer6);//entry 17
206
207 TH1F *gHistSSDRadiusLayer5 = new TH1F("fHistSSDRadiusLayer5",
208 "r - Layer 5;r [cm];Entries;",
209 100,35.,50.);
210 fHistSSDArray->Add(gHistSSDRadiusLayer5);//entry 18
211
212 TH1F *gHistSSDRadiusLayer6 = new TH1F("fHistSSDRadiusLayer6",
213 "r - Layer 6;r [cm];Entries;",
214 100,35.,50.);
215 fHistSSDArray->Add(gHistSSDRadiusLayer6);//entry 19
216
217 TH1F *gHistSSDClusterTypeLayer5 = new TH1F("Layer5/fHistSSDClusterTypeLayer5",
218 "CL type - Layer 5;Cluster type;Entries;",
219 150,0,150);
220 fHistSSDArray->Add(gHistSSDClusterTypeLayer5);//entry 20
221
222 TH1F *gHistSSDClusterTypeLayer6 = new TH1F("fHistSSDClusterTypeLayer6",
223 "CL type - Layer 6;Cluster type;Entries;",
224 150,0,150);
225 fHistSSDArray->Add(gHistSSDClusterTypeLayer6);//entry 21
226
227 TH1F *gHistSSDChargeRatioLayer5 = new TH1F("fHistSSDChargeRatioLayer5",
228 "Charge ratio - Layer 5;q_{ratio};Entries;",
229 100,-2.0,2.0);
230 fHistSSDArray->Add(gHistSSDChargeRatioLayer5);//entry 22
231
232 TH1F *gHistSSDChargeRatioLayer6 = new TH1F("fHistSSDChargeRatioLayer6",
233 "Charge ratio - Layer 6;q_{ratio};Entries;",
234 100,-2.0,2.0);
235 fHistSSDArray->Add(gHistSSDChargeRatioLayer6);//entry 23
236
237 TH1F *gHistSSDChargekeVLayer5 = new TH1F("fHistSSDChargekeVLayer5",
238 "Charge - Layer 5;q [keV];Entries;",
239 100,0.,300.);
240 fHistSSDArray->Add(gHistSSDChargekeVLayer5);//entry 24
241
242 TH1F *gHistSSDChargekeVLayer6 = new TH1F("fHistSSDChargekeVLayer6",
243 "Charge - Layer 6;q [keV];Entries;",
244 100,0.,300.);
245 fHistSSDArray->Add(gHistSSDChargekeVLayer6);//entry 25
246
247 TH1F *gHistSSDChargePSideLayer5 = new TH1F("fHistSSDChargePSideLayer5",
248 "Charge P- Layer 5;q_{P} [keV];Entries;",
249 100,0.,300.);
250 fHistSSDArray->Add(gHistSSDChargePSideLayer5);//entry 26
251
252 TH1F *gHistSSDChargePSideLayer6 = new TH1F("fHistSSDChargePSideLayer6",
253 "Charge P- Layer 6;q_{P} [keV];Entries;",
254 100,0.,300.);
255 fHistSSDArray->Add(gHistSSDChargePSideLayer6);//entry 27
256
257 TH1F *gHistSSDChargeNSideLayer5 = new TH1F("fHistSSDChargeNSideLayer5",
258 "Charge N- Layer 5;q_{N} [keV];Entries;",
259 100,0.,300.);
260 fHistSSDArray->Add(gHistSSDChargeNSideLayer5);//entry 28
261
262 TH1F *gHistSSDChargeNSideLayer6 = new TH1F("fHistSSDChargeNSideLayer6",
263 "Charge N- Layer 6;q_{N} [keV];Entries;",
264 100,0.,300.);
265 fHistSSDArray->Add(gHistSSDChargeNSideLayer6);//entry 29
266
267 TH1F *gHistSSDChargeRatio2Layer5 = new TH1F("fHistSSDChargeRatio2Layer5",
268 "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
269 100,0,2);
270 fHistSSDArray->Add(gHistSSDChargeRatio2Layer5);//entry 30
271
272 TH1F *gHistSSDChargeRatio2Layer6 = new TH1F("fHistSSDChargeRatio2Layer6",
273 "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
274 100,0,2);
275 fHistSSDArray->Add(gHistSSDChargeRatio2Layer6);//entry 31
276
277 TH2F *gHistSSDChargePNSideLayer5 = new TH2F("fHistSSDChargePNSideLayer5",
278 "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
279 100,0.,300.,
280 100,0.,300.);
281 fHistSSDArray->Add(gHistSSDChargePNSideLayer5);//entry 32
282
283 TH2F *gHistSSDChargePNSideLayer6 = new TH2F("fHistSSDChargePNSideLayer6",
284 "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
285 100,0.,300.,
286 100,0.,300.);
287 fHistSSDArray->Add(gHistSSDChargePNSideLayer6);//entry 33
288
289 TH2F *gHistSSDChargeMapLayer5 = new TH2F("fHistSSDChargeMapLayer5",
290 "Charge map;N_{modules};N_{Ladders}",
291 fgkSSDMODULESPERLADDERLAYER5,
292 -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,
293 3*fgkSSDLADDERSLAYER5,
294 -0.5,fgkSSDLADDERSLAYER5+0.5);
295 fHistSSDArray->Add(gHistSSDChargeMapLayer5);//entry 34
296
297 TH2F *gHistSSDChargeMapLayer6 = new TH2F("fHistSSDChargeMapLayer6",
298 "Charge map;N_{modules};N_{Ladders}",
299 fgkSSDMODULESPERLADDERLAYER6,
300 -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,
301 3*fgkSSDLADDERSLAYER6,
302 -0.5,fgkSSDLADDERSLAYER6+0.5);
303 fHistSSDArray->Add(gHistSSDChargeMapLayer6);//entry 35
304
305 TH2F *gHistSSDClusterMapLayer5 = new TH2F("fHistSSDClusterMapLayer5",
306 "Layer 5;N_{module};N_{ladder}",
307 22,1,23,
308 34,500,534);
309 gHistSSDClusterMapLayer5->GetXaxis()->SetTitleColor(1);
310 gHistSSDClusterMapLayer5->SetStats(kFALSE);
311 gHistSSDClusterMapLayer5->GetYaxis()->SetTitleOffset(1.8);
312 gHistSSDClusterMapLayer5->GetXaxis()->SetNdivisions(22);
313 gHistSSDClusterMapLayer5->GetYaxis()->SetNdivisions(34);
314 gHistSSDClusterMapLayer5->GetXaxis()->SetLabelSize(0.03);
315 gHistSSDClusterMapLayer5->GetYaxis()->SetLabelSize(0.03);
316 gHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
317 gHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
318 fHistSSDArray->Add(gHistSSDClusterMapLayer5); //entry 36
319
320 TH2F *gHistSSDClusterMapLayer6 = new TH2F("fHistSSDClusterMapLayer6",
321 "Layer 6;N_{module};N_{ladder}",
322 25,1,26,
323 38,600,638);
324 gHistSSDClusterMapLayer6->GetXaxis()->SetTitleColor(1);
325 gHistSSDClusterMapLayer6->SetStats(kFALSE);
326 gHistSSDClusterMapLayer6->GetYaxis()->SetTitleOffset(1.8);
327 gHistSSDClusterMapLayer6->GetXaxis()->SetNdivisions(25);
328 gHistSSDClusterMapLayer6->GetYaxis()->SetNdivisions(38);
329 gHistSSDClusterMapLayer6->GetXaxis()->SetLabelSize(0.03);
330 gHistSSDClusterMapLayer6->GetYaxis()->SetLabelSize(0.03);
331 gHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
332 gHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
333 fHistSSDArray->Add(gHistSSDClusterMapLayer6);//entry 37
fd091d74 334
335 HLTInfo("Finished initialization of SSD histograms");
336
4b1ad1e4 337 return 0;
fd091d74 338}
339
340int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
341 // see header file for class documentation
4b1ad1e4 342 if(fHistSSDArray) delete fHistSSDArray;
343
fd091d74 344 return 0;
345}
346
347int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
348{
349
4b1ad1e4 350 Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;
351
fd091d74 352 const AliHLTComponentBlockData* iter = NULL;
353
354 if(!IsDataEvent())
355 return 0;
4b1ad1e4 356
357 for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
fd091d74 358
359 if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD))
4b1ad1e4 360 continue;
361
fd091d74 362 const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
363 Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
fd091d74 364 AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints;
4b1ad1e4 365
366 for(int i = 0; i < nSpacepoint; i++) { //cluster loop
fd091d74 367 Int_t lab[4]={0,0,0,0};
368 Float_t hit[6]={0,0,0,0,0,0};
369 Int_t info[3]={0,0,0};
370
371 lab[0]=clusters[i].fTracks[0];
372 lab[1]=clusters[i].fTracks[1];
373 lab[2]=clusters[i].fTracks[2];
374 lab[3]=clusters[i].fIndex;
375 hit[0]=clusters[i].fY;
376 hit[1]=clusters[i].fZ;
377 hit[2]=clusters[i].fSigmaY2;
378 hit[3]=clusters[i].fSigmaZ2;
379 hit[4]=clusters[i].fQ;
380 hit[5]=clusters[i].fSigmaYZ;
381 info[0]=clusters[i].fNy;
382 info[1]=clusters[i].fNz;
383 info[2]=clusters[i].fLayer;
4b1ad1e4 384
fd091d74 385 AliITSRecPoint recp(lab,hit,info);
fd091d74 386
4b1ad1e4 387 Int_t module = 0;
388 Int_t gLayer = 0, gLadder = 0, gModule = 0;
389 Int_t lLadderLocationY = 0;
390
391 Float_t cluglo[3]={0.,0.,0.};
392
393 Int_t layer = recp.GetLayer();
394 if (layer == 4) module = recp.GetDetectorIndex() + 500;
395 if (layer == 5) module = recp.GetDetectorIndex() + 1248;
396
397 AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);
398 lLadderLocationY = 3*gLadder;
399
400 recp.GetGlobalXYZ(cluglo);
401 Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]);
402 Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);
403 Float_t theta = TMath::ATan2(radius,cluglo[2]);
404 Double_t chargeRatio = recp.GetChargeRatio();
405 Double_t clusterCharge = recp.GetQ();
406 Double_t chargePSide = clusterCharge*(1. + chargeRatio);
407 Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
408
fd091d74 409 if(layer == 4) {
4b1ad1e4 410 dynamic_cast<TH1F *>(fHistSSDArray->At(0))->Fill(module);
411 dynamic_cast<TH1F *>(fHistSSDArray->At(4))->Fill(recp.GetDetLocalX());
412 dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
413 dynamic_cast<TH1F *>(fHistSSDArray->At(8))->Fill(cluglo[0]);
414 dynamic_cast<TH1F *>(fHistSSDArray->At(10))->Fill(cluglo[1]);
415 dynamic_cast<TH1F *>(fHistSSDArray->At(12))->Fill(cluglo[2]);
416 dynamic_cast<TH1F *>(fHistSSDArray->At(14))->Fill(phi);
417 dynamic_cast<TH1F *>(fHistSSDArray->At(16))->Fill(theta);
418 dynamic_cast<TH1F *>(fHistSSDArray->At(18))->Fill(radius);
419 dynamic_cast<TH1F *>(fHistSSDArray->At(20))->Fill(recp.GetType());
420 dynamic_cast<TH1F *>(fHistSSDArray->At(22))->Fill(recp.GetChargeRatio());
421 dynamic_cast<TH1F *>(fHistSSDArray->At(24))->Fill(recp.GetQ());
422 dynamic_cast<TH1F *>(fHistSSDArray->At(26))->Fill(chargePSide);
423 dynamic_cast<TH1F *>(fHistSSDArray->At(28))->Fill(chargeNSide);
424 if(chargePSide != 0.)
425 dynamic_cast<TH1F *>(fHistSSDArray->At(30))->Fill(chargeNSide/chargePSide);
426 dynamic_cast<TH2F *>(fHistSSDArray->At(32))->Fill(chargePSide,
427 chargeNSide);
428 dynamic_cast<TH2F *>(fHistSSDArray->At(34))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
429 dynamic_cast<TH2F *>(fHistSSDArray->At(36))->Fill(gModule,499+gLadder,1);
fd091d74 430 nClustersLayer5 += 1;
431 }//layer 5 histograms
432 if(layer == 5) {
4b1ad1e4 433 dynamic_cast<TH1F *>(fHistSSDArray->At(1))->Fill(module);
434 dynamic_cast<TH1F *>(fHistSSDArray->At(5))->Fill(recp.GetDetLocalX());
435 dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
436 dynamic_cast<TH1F *>(fHistSSDArray->At(9))->Fill(cluglo[0]);
437 dynamic_cast<TH1F *>(fHistSSDArray->At(11))->Fill(cluglo[1]);
438 dynamic_cast<TH1F *>(fHistSSDArray->At(13))->Fill(cluglo[2]);
439 dynamic_cast<TH1F *>(fHistSSDArray->At(15))->Fill(phi);
440 dynamic_cast<TH1F *>(fHistSSDArray->At(17))->Fill(theta);
441 dynamic_cast<TH1F *>(fHistSSDArray->At(19))->Fill(radius);
442 dynamic_cast<TH1F *>(fHistSSDArray->At(21))->Fill(recp.GetType());
443 dynamic_cast<TH1F *>(fHistSSDArray->At(23))->Fill(recp.GetChargeRatio());
444 dynamic_cast<TH1F *>(fHistSSDArray->At(25))->Fill(recp.GetQ());
445 dynamic_cast<TH1F *>(fHistSSDArray->At(27))->Fill(chargePSide);
446 dynamic_cast<TH1F *>(fHistSSDArray->At(29))->Fill(chargeNSide);
447 if(chargePSide != 0.)
448 dynamic_cast<TH1F *>(fHistSSDArray->At(31))->Fill(chargeNSide/chargePSide);
449 dynamic_cast<TH2F *>(fHistSSDArray->At(33))->Fill(chargePSide,
450 chargeNSide);
451 dynamic_cast<TH2F *>(fHistSSDArray->At(35))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
452 dynamic_cast<TH2F *>(fHistSSDArray->At(37))->Fill(gModule,599+gLadder,1);
fd091d74 453 nClustersLayer6 += 1;
454 }//layer 6 histograms
455 }//cluster loop
4b1ad1e4 456 dynamic_cast<TH1F *>(fHistSSDArray->At(2))->Fill(nClustersLayer5);
457 dynamic_cast<TH1F *>(fHistSSDArray->At(3))->Fill(nClustersLayer6);
458 }//input block
459
460 //Publish array
461 AliHLTUInt32_t fSpecification = 0x0;
462 PushBack( (TObjArray*) fHistSSDArray,kAliHLTDataTypeTObjArray|kAliHLTDataOriginITSSSD,fSpecification);
463
464 HLTInfo("ITSSSDQARecPoints found %d SSD clusters", nClustersLayer5+nClustersLayer6);
fd091d74 465
4b1ad1e4 466 return 0;
fd091d74 467}