- correct initialization of geometry for the component to work in the HLT framework
[u/mrichter/AliRoot.git] / HLT / ITS / AliHLTITSSSDQARecPointsComponent.cxx
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
19     @author Ingrid Kielen - Panos Christakoglou (Panos.Christakoglou@cern.ch)
20     @brief  Component for the SSD clusters QA
21 */
22
23 #if __GNUC__>= 3
24 using 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"
37 #include "TH1.h"
38 #include "TH2.h"
39 #include "AliITSgeomTGeo.h"
40 #include "AliGeomManager.h"
41
42 //#include <stdlib.h>
43 //#include <cerrno>
44
45 /** ROOT macro for the implementation of ROOT specific class methods */
46 ClassImp(AliHLTITSSSDQARecPointsComponent)
47
48 AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent()
49   :AliHLTProcessor(),
50    fHistSSDArray(NULL) {
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
59 AliHLTITSSSDQARecPointsComponent::~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
67 const char* AliHLTITSSSDQARecPointsComponent::GetComponentID()
68 {
69   // see header file for class documentation
70   
71   return "ITSSSDQARecPoints";
72 }
73
74 void AliHLTITSSSDQARecPointsComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
75   // see header file for class documentation
76   list.clear();
77   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
78 }
79
80 AliHLTComponentDataType AliHLTITSSSDQARecPointsComponent::GetOutputDataType() {
81   // see header file for class documentation
82   return kAliHLTDataTypeTObjArray;
83 }
84
85 void 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
93 AliHLTComponent* AliHLTITSSSDQARecPointsComponent::Spawn()
94 {
95   // see header file for class documentation
96   return new AliHLTITSSSDQARecPointsComponent;
97 }
98
99 int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) {
100   //Inititalization of histograms for the SSD QA component
101   
102   
103   if(AliGeomManager::GetGeometry()==NULL){
104      AliGeomManager::LoadGeometry();
105   }
106   
107   
108   fHistSSDArray = new TObjArray();  
109   fHistSSDArray->SetName("ssdArray");
110
111   Int_t nModuleOffset = 500;
112   Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();  
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
334
335   HLTInfo("Finished initialization of SSD histograms");  
336
337   return 0;  
338 }
339   
340 int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
341   // see header file for class documentation
342   if(fHistSSDArray) delete fHistSSDArray;
343
344   return 0;
345 }
346
347 int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
348 {
349   
350   Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;   
351   
352   const AliHLTComponentBlockData* iter = NULL;
353   
354   if(!IsDataEvent())
355     return 0;
356   
357   for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
358     
359     if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD))
360       continue;
361     
362     const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
363     Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
364     AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints;
365     
366     for(int i = 0; i < nSpacepoint; i++) { //cluster loop
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;
384       
385       AliITSRecPoint recp(lab,hit,info);
386       
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       
409       if(layer == 4) {
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);
430         nClustersLayer5 += 1;
431       }//layer 5 histograms
432       if(layer == 5) {
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);
453         nClustersLayer6 += 1;
454       }//layer 6 histograms
455     }//cluster loop
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);
465
466  return 0;
467 }