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