]>
Commit | Line | Data |
---|---|---|
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 | ||
fd091d74 | 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" | |
4b1ad1e4 | 33 | #include "TH1.h" |
34 | #include "TH2.h" | |
fd091d74 | 35 | #include "AliITSgeomTGeo.h" |
b5284ba2 | 36 | #include "AliGeomManager.h" |
fd091d74 | 37 | |
38 | //#include <stdlib.h> | |
39 | //#include <cerrno> | |
40 | ||
8e0f6ca3 | 41 | using namespace std; |
42 | ||
fd091d74 | 43 | /** ROOT macro for the implementation of ROOT specific class methods */ |
44 | ClassImp(AliHLTITSSSDQARecPointsComponent) | |
45 | ||
46 | AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent() | |
47 | :AliHLTProcessor(), | |
4b1ad1e4 | 48 | fHistSSDArray(NULL) { |
fd091d74 | 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 | } | |
56 | ||
57 | AliHLTITSSSDQARecPointsComponent::~AliHLTITSSSDQARecPointsComponent() | |
58 | { | |
59 | // see header file for class documentation | |
60 | } | |
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 | return "ITSSSDQARecPoints"; | |
70 | } | |
71 | ||
72 | void AliHLTITSSSDQARecPointsComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) { | |
73 | // see header file for class documentation | |
74 | list.clear(); | |
75 | list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD ); | |
76 | } | |
77 | ||
78 | AliHLTComponentDataType AliHLTITSSSDQARecPointsComponent::GetOutputDataType() { | |
79 | // see header file for class documentation | |
80 | 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 | constBase = 80000; | |
88 | inputMultiplier = 10; | |
89 | } | |
90 | ||
91 | AliHLTComponent* AliHLTITSSSDQARecPointsComponent::Spawn() | |
92 | { | |
93 | // see header file for class documentation | |
94 | return new AliHLTITSSSDQARecPointsComponent; | |
95 | } | |
96 | ||
4b1ad1e4 | 97 | int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) { |
fd091d74 | 98 | //Inititalization of histograms for the SSD QA component |
b5284ba2 | 99 | |
100 | ||
101 | if(AliGeomManager::GetGeometry()==NULL){ | |
102 | AliGeomManager::LoadGeometry(); | |
103 | } | |
104 | ||
105 | ||
4b1ad1e4 | 106 | fHistSSDArray = new TObjArray(); |
107 | fHistSSDArray->SetName("ssdArray"); | |
fd091d74 | 108 | |
109 | Int_t nModuleOffset = 500; | |
110 | Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules(); | |
4b1ad1e4 | 111 | TH1F *gHistSSDModuleIdLayer5 = new TH1F("fHistSSDModuleIdLayer5", |
112 | "Module Id - Layer 5;Module Id;Entries", | |
113 | fgkSSDMODULESLAYER5, | |
114 | nModuleOffset - 0.5, | |
115 | nITSTotalModules-fgkSSDMODULESLAYER6+0.5); | |
116 | fHistSSDArray->Add(gHistSSDModuleIdLayer5);//entry 0 | |
117 | ||
118 | TH1F *gHistSSDModuleIdLayer6 = new TH1F("fHistSSDModuleIdLayer6", | |
119 | "Module Id - Layer 6;Module Id;Entries", | |
120 | fgkSSDMODULESLAYER6, | |
121 | nModuleOffset+fgkSSDMODULESLAYER5 - 0.5, | |
122 | nITSTotalModules + 0.5); | |
123 | fHistSSDArray->Add(gHistSSDModuleIdLayer6);//entry 1 | |
124 | ||
125 | TH1F *gHistSSDClusterPerEventLayer5 = new TH1F("fHistSSDClusterPerEventLayer5", | |
126 | "N_{clusters} - Layer 5;N_{clusters};Entries;", | |
127 | 100,0.1,5000); | |
128 | fHistSSDArray->Add(gHistSSDClusterPerEventLayer5);//entry 2 | |
129 | ||
130 | TH1F *gHistSSDClusterPerEventLayer6 = new TH1F("fHistSSDClusterPerEventLayer6", | |
131 | "N_{clusters} - Layer 6;N_{clusters};Entries;", | |
132 | 100,0.1,5000); | |
133 | fHistSSDArray->Add(gHistSSDClusterPerEventLayer6);//entry 3 | |
134 | ||
135 | TH1F *gHistSSDLocalXLayer5 = new TH1F("fHistSSDLocalXLayer5", | |
136 | "Local x coord.- Layer 5;x [cm];Entries;", | |
137 | 100,-4.,4.); | |
138 | fHistSSDArray->Add(gHistSSDLocalXLayer5);//entry 4 | |
139 | ||
140 | TH1F *gHistSSDLocalXLayer6 = new TH1F("fHistSSDLocalXLayer6", | |
141 | "Local x coord.- Layer 6;x [cm];Entries;", | |
142 | 100,-4.,4.); | |
143 | fHistSSDArray->Add(gHistSSDLocalXLayer6);//entry 5 | |
144 | ||
145 | TH1F *gHistSSDLocalZLayer5 = new TH1F("fHistSSDLocalZLayer5", | |
146 | "Local z coord.- Layer 5;z [cm];Entries;", | |
147 | 100,-4.,4.); | |
148 | fHistSSDArray->Add(gHistSSDLocalZLayer5);//entry 6 | |
149 | ||
150 | TH1F *gHistSSDLocalZLayer6 = new TH1F("fHistSSDLocalZLayer6", | |
151 | "Local z coord.- Layer 6;z [cm];Entries;", | |
152 | 100,-4.,4.); | |
153 | fHistSSDArray->Add(gHistSSDLocalZLayer6);//entry 7 | |
154 | ||
155 | TH1F *gHistSSDGlobalXLayer5 = new TH1F("fHistSSDGlobalXLayer5", | |
156 | "Global x - Layer 5;x [cm];Entries;", | |
157 | 100,-40.,40.); | |
158 | fHistSSDArray->Add(gHistSSDGlobalXLayer5);//entry 8 | |
159 | ||
160 | TH1F *gHistSSDGlobalXLayer6 = new TH1F("fHistSSDGlobalXLayer6", | |
161 | "Global x - Layer 6;x [cm];Entries;", | |
162 | 100,-45.,45.); | |
163 | fHistSSDArray->Add(gHistSSDGlobalXLayer6);//entry 9 | |
164 | ||
165 | TH1F *gHistSSDGlobalYLayer5 = new TH1F("fHistSSDGlobalYLayer5", | |
166 | "Global y - Layer 5;y [cm];Entries;", | |
167 | 100,-40.,40); | |
168 | fHistSSDArray->Add(gHistSSDGlobalYLayer5);//entry 10 | |
169 | ||
170 | TH1F *gHistSSDGlobalYLayer6 = new TH1F("fHistSSDGlobalYLayer6", | |
171 | "Global y - Layer 6;y [cm];Entries;", | |
172 | 100,-45.,45.); | |
173 | fHistSSDArray->Add(gHistSSDGlobalYLayer6);//entry 11 | |
174 | ||
175 | TH1F *gHistSSDGlobalZLayer5 = new TH1F("fHistSSDGlobalZLayer5", | |
176 | "Global z - Layer 5;z [cm];Entries;", | |
177 | 100,-45.,45); | |
178 | fHistSSDArray->Add(gHistSSDGlobalZLayer5);//entry 12 | |
179 | ||
180 | TH1F *gHistSSDGlobalZLayer6 = new TH1F("fHistSSDGlobalZLayer6", | |
181 | "Global z - Layer 6;z [cm];Entries;", | |
182 | 100,-55.,55.); | |
183 | fHistSSDArray->Add(gHistSSDGlobalZLayer6);//entry 13 | |
184 | ||
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 | |
189 | ||
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 | |
194 | ||
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 | |
199 | ||
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 | |
204 | ||
205 | TH1F *gHistSSDRadiusLayer5 = new TH1F("fHistSSDRadiusLayer5", | |
206 | "r - Layer 5;r [cm];Entries;", | |
207 | 100,35.,50.); | |
208 | fHistSSDArray->Add(gHistSSDRadiusLayer5);//entry 18 | |
209 | ||
210 | TH1F *gHistSSDRadiusLayer6 = new TH1F("fHistSSDRadiusLayer6", | |
211 | "r - Layer 6;r [cm];Entries;", | |
212 | 100,35.,50.); | |
213 | fHistSSDArray->Add(gHistSSDRadiusLayer6);//entry 19 | |
214 | ||
215 | TH1F *gHistSSDClusterTypeLayer5 = new TH1F("Layer5/fHistSSDClusterTypeLayer5", | |
216 | "CL type - Layer 5;Cluster type;Entries;", | |
217 | 150,0,150); | |
218 | fHistSSDArray->Add(gHistSSDClusterTypeLayer5);//entry 20 | |
219 | ||
220 | TH1F *gHistSSDClusterTypeLayer6 = new TH1F("fHistSSDClusterTypeLayer6", | |
221 | "CL type - Layer 6;Cluster type;Entries;", | |
222 | 150,0,150); | |
223 | fHistSSDArray->Add(gHistSSDClusterTypeLayer6);//entry 21 | |
224 | ||
225 | TH1F *gHistSSDChargeRatioLayer5 = new TH1F("fHistSSDChargeRatioLayer5", | |
226 | "Charge ratio - Layer 5;q_{ratio};Entries;", | |
227 | 100,-2.0,2.0); | |
228 | fHistSSDArray->Add(gHistSSDChargeRatioLayer5);//entry 22 | |
229 | ||
230 | TH1F *gHistSSDChargeRatioLayer6 = new TH1F("fHistSSDChargeRatioLayer6", | |
231 | "Charge ratio - Layer 6;q_{ratio};Entries;", | |
232 | 100,-2.0,2.0); | |
233 | fHistSSDArray->Add(gHistSSDChargeRatioLayer6);//entry 23 | |
234 | ||
235 | TH1F *gHistSSDChargekeVLayer5 = new TH1F("fHistSSDChargekeVLayer5", | |
236 | "Charge - Layer 5;q [keV];Entries;", | |
237 | 100,0.,300.); | |
238 | fHistSSDArray->Add(gHistSSDChargekeVLayer5);//entry 24 | |
239 | ||
240 | TH1F *gHistSSDChargekeVLayer6 = new TH1F("fHistSSDChargekeVLayer6", | |
241 | "Charge - Layer 6;q [keV];Entries;", | |
242 | 100,0.,300.); | |
243 | fHistSSDArray->Add(gHistSSDChargekeVLayer6);//entry 25 | |
244 | ||
245 | TH1F *gHistSSDChargePSideLayer5 = new TH1F("fHistSSDChargePSideLayer5", | |
246 | "Charge P- Layer 5;q_{P} [keV];Entries;", | |
247 | 100,0.,300.); | |
248 | fHistSSDArray->Add(gHistSSDChargePSideLayer5);//entry 26 | |
249 | ||
250 | TH1F *gHistSSDChargePSideLayer6 = new TH1F("fHistSSDChargePSideLayer6", | |
251 | "Charge P- Layer 6;q_{P} [keV];Entries;", | |
252 | 100,0.,300.); | |
253 | fHistSSDArray->Add(gHistSSDChargePSideLayer6);//entry 27 | |
254 | ||
255 | TH1F *gHistSSDChargeNSideLayer5 = new TH1F("fHistSSDChargeNSideLayer5", | |
256 | "Charge N- Layer 5;q_{N} [keV];Entries;", | |
257 | 100,0.,300.); | |
258 | fHistSSDArray->Add(gHistSSDChargeNSideLayer5);//entry 28 | |
259 | ||
260 | TH1F *gHistSSDChargeNSideLayer6 = new TH1F("fHistSSDChargeNSideLayer6", | |
261 | "Charge N- Layer 6;q_{N} [keV];Entries;", | |
262 | 100,0.,300.); | |
263 | fHistSSDArray->Add(gHistSSDChargeNSideLayer6);//entry 29 | |
264 | ||
265 | TH1F *gHistSSDChargeRatio2Layer5 = new TH1F("fHistSSDChargeRatio2Layer5", | |
266 | "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;", | |
267 | 100,0,2); | |
268 | fHistSSDArray->Add(gHistSSDChargeRatio2Layer5);//entry 30 | |
269 | ||
270 | TH1F *gHistSSDChargeRatio2Layer6 = new TH1F("fHistSSDChargeRatio2Layer6", | |
271 | "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;", | |
272 | 100,0,2); | |
273 | fHistSSDArray->Add(gHistSSDChargeRatio2Layer6);//entry 31 | |
274 | ||
275 | 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 | fHistSSDArray->Add(gHistSSDChargePNSideLayer5);//entry 32 | |
280 | ||
281 | 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 | fHistSSDArray->Add(gHistSSDChargePNSideLayer6);//entry 33 | |
286 | ||
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 | |
294 | ||
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 | |
302 | ||
303 | TH2F *gHistSSDClusterMapLayer5 = new TH2F("fHistSSDClusterMapLayer5", | |
304 | "Layer 5;N_{module};N_{ladder}", | |
305 | 22,1,23, | |
306 | 34,500,534); | |
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 | |
317 | ||
318 | TH2F *gHistSSDClusterMapLayer6 = new TH2F("fHistSSDClusterMapLayer6", | |
319 | "Layer 6;N_{module};N_{ladder}", | |
320 | 25,1,26, | |
321 | 38,600,638); | |
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 | |
fd091d74 | 332 | |
333 | HLTInfo("Finished initialization of SSD histograms"); | |
334 | ||
4b1ad1e4 | 335 | return 0; |
fd091d74 | 336 | } |
337 | ||
338 | int AliHLTITSSSDQARecPointsComponent::DoDeinit() { | |
339 | // see header file for class documentation | |
4b1ad1e4 | 340 | if(fHistSSDArray) delete fHistSSDArray; |
341 | ||
fd091d74 | 342 | return 0; |
343 | } | |
344 | ||
345 | int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/) | |
346 | { | |
347 | ||
4b1ad1e4 | 348 | Int_t nClustersLayer5 = 0, nClustersLayer6 = 0; |
349 | ||
fd091d74 | 350 | const AliHLTComponentBlockData* iter = NULL; |
351 | ||
352 | if(!IsDataEvent()) | |
353 | return 0; | |
4b1ad1e4 | 354 | |
355 | for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) { | |
fd091d74 | 356 | |
357 | if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD)) | |
4b1ad1e4 | 358 | continue; |
359 | ||
fd091d74 | 360 | const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr; |
361 | Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt; | |
fd091d74 | 362 | AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints; |
4b1ad1e4 | 363 | |
364 | for(int i = 0; i < nSpacepoint; i++) { //cluster loop | |
fd091d74 | 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}; | |
368 | ||
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; | |
4b1ad1e4 | 382 | |
fd091d74 | 383 | AliITSRecPoint recp(lab,hit,info); |
fd091d74 | 384 | |
4b1ad1e4 | 385 | Int_t module = 0; |
386 | Int_t gLayer = 0, gLadder = 0, gModule = 0; | |
387 | Int_t lLadderLocationY = 0; | |
388 | ||
389 | Float_t cluglo[3]={0.,0.,0.}; | |
390 | ||
391 | Int_t layer = recp.GetLayer(); | |
392 | if (layer == 4) module = recp.GetDetectorIndex() + 500; | |
393 | if (layer == 5) module = recp.GetDetectorIndex() + 1248; | |
394 | ||
395 | AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule); | |
396 | lLadderLocationY = 3*gLadder; | |
397 | ||
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); | |
406 | ||
fd091d74 | 407 | if(layer == 4) { |
4b1ad1e4 | 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, | |
425 | chargeNSide); | |
426 | dynamic_cast<TH2F *>(fHistSSDArray->At(34))->SetBinContent(gModule,lLadderLocationY,recp.GetQ()); | |
427 | dynamic_cast<TH2F *>(fHistSSDArray->At(36))->Fill(gModule,499+gLadder,1); | |
fd091d74 | 428 | nClustersLayer5 += 1; |
429 | }//layer 5 histograms | |
430 | if(layer == 5) { | |
4b1ad1e4 | 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, | |
448 | chargeNSide); | |
449 | dynamic_cast<TH2F *>(fHistSSDArray->At(35))->SetBinContent(gModule,lLadderLocationY,recp.GetQ()); | |
450 | dynamic_cast<TH2F *>(fHistSSDArray->At(37))->Fill(gModule,599+gLadder,1); | |
fd091d74 | 451 | nClustersLayer6 += 1; |
452 | }//layer 6 histograms | |
453 | }//cluster loop | |
4b1ad1e4 | 454 | dynamic_cast<TH1F *>(fHistSSDArray->At(2))->Fill(nClustersLayer5); |
455 | dynamic_cast<TH1F *>(fHistSSDArray->At(3))->Fill(nClustersLayer6); | |
456 | }//input block | |
457 | ||
458 | //Publish array | |
459 | AliHLTUInt32_t fSpecification = 0x0; | |
460 | PushBack( (TObjArray*) fHistSSDArray,kAliHLTDataTypeTObjArray|kAliHLTDataOriginITSSSD,fSpecification); | |
461 | ||
462 | HLTInfo("ITSSSDQARecPoints found %d SSD clusters", nClustersLayer5+nClustersLayer6); | |
fd091d74 | 463 | |
4b1ad1e4 | 464 | return 0; |
fd091d74 | 465 | } |