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 }