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 #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 ClassImp(AliHLTITSSSDQARecPointsComponent)
  45
  46 AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent()
  47   :AliHLTProcessor(),
  48    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 }
  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
  97 int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) {
  98   //Inititalization of histograms for the SSD QA component
  99
 100
 101   if(AliGeomManager::GetGeometry()==NULL){
 102      AliGeomManager::LoadGeometry();
 103   }
 104
 105
 106   fHistSSDArray = new TObjArray();
 107   fHistSSDArray->SetName("ssdArray");
 108
 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",
 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
 332
 333   HLTInfo("Finished initialization of SSD histograms");
 334
 335   return 0;
 336 }
 337
 338 int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
 339   // see header file for class documentation
 340   if(fHistSSDArray) delete fHistSSDArray;
 341
 342   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   if(!IsDataEvent())
 353     return 0;
 354
 355   for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
 356
 357     if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD))
 358       continue;
 359
 360     const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
 361     Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
 362     AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints;
 363
 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};
 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;
 382
 383       AliITSRecPoint recp(lab,hit,info);
 384
 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
 407       if(layer == 4) {
 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);
 428         nClustersLayer5 += 1;
 429       }//layer 5 histograms
 430       if(layer == 5) {
 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);
 451         nClustersLayer6 += 1;
 452       }//layer 6 histograms
 453     }//cluster loop
 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);
 463
 464  return 0;
 465 }