[u/mrichter/AliRoot.git] / HLT / ITS / AliHLTITSSSDQARecPointsComponent.cxx

// $Id$
//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Ingrid Kielen                                         *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* Permission to use, copy, modify and distribute this software and its   *
//* documentation strictly for non-commercial purposes is hereby granted   *
//* without fee, provided that the above copyright notice appears in all   *
//* copies and that both the copyright notice and this permission notice   *
//* appear in the supporting documentation. The authors make no claims     *
//* about the suitability of this software for any purpose. It is          *
//* provided "as is" without express or implied warranty.                  *
//**************************************************************************

/** @file   AliHLTITSSSDQARecPointsComponent.cxx
    @author Ingrid Kielen - Panos Christakoglou (Panos.Christakoglou@cern.ch)
    @brief  Component for the SSD clusters QA
*/

#if __GNUC__>= 3
using namespace std;
#endif

#include "AliHLTITSSSDQARecPointsComponent.h"
#include "AliHLTITSClusterDataFormat.h"
#include "AliCDBEntry.h"
#include "AliCDBManager.h"
#include "AliITSRecPoint.h"
#include <TFile.h>
#include <TMath.h>
#include <TString.h>
#include "TObjString.h"
#include "TObjArray.h"
#include "TH1.h"
#include "TH2.h"
#include "AliITSgeomTGeo.h"
#include "AliGeomManager.h"

//#include <stdlib.h>
//#include <cerrno>

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTITSSSDQARecPointsComponent)

AliHLTITSSSDQARecPointsComponent::AliHLTITSSSDQARecPointsComponent()
  :AliHLTProcessor(),
   fHistSSDArray(NULL) {
  // see header file for class documentation
  // or
  // refer to README to build package
  // or
  // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt

}

AliHLTITSSSDQARecPointsComponent::~AliHLTITSSSDQARecPointsComponent()
{
  // see header file for class documentation
}

// Public functions to implement AliHLTComponent's interface.
// These functions are required for the registration process

const char* AliHLTITSSSDQARecPointsComponent::GetComponentID()
{
  // see header file for class documentation
  
  return "ITSSSDQARecPoints";
}

void AliHLTITSSSDQARecPointsComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) {
  // see header file for class documentation
  list.clear();
  list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
}

AliHLTComponentDataType AliHLTITSSSDQARecPointsComponent::GetOutputDataType() {
  // see header file for class documentation
  return kAliHLTDataTypeTObjArray;
}

void AliHLTITSSSDQARecPointsComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
{
  // see header file for class documentation
  // XXX TODO: Find more realistic values.
  constBase = 80000;
  inputMultiplier = 10;
}

AliHLTComponent* AliHLTITSSSDQARecPointsComponent::Spawn()
{
  // see header file for class documentation
  return new AliHLTITSSSDQARecPointsComponent;
}

int AliHLTITSSSDQARecPointsComponent::DoInit(int /*argc*/, const char** /*argv*/) {
  //Inititalization of histograms for the SSD QA component
  
  
  if(AliGeomManager::GetGeometry()==NULL){
     AliGeomManager::LoadGeometry();
  }
  
  
  fHistSSDArray = new TObjArray();  
  fHistSSDArray->SetName("ssdArray");

  Int_t nModuleOffset = 500;
  Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();  
  TH1F *gHistSSDModuleIdLayer5 = new TH1F("fHistSSDModuleIdLayer5",
					  "Module Id - Layer 5;Module Id;Entries",
					  fgkSSDMODULESLAYER5,
					  nModuleOffset - 0.5,
					  nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
  fHistSSDArray->Add(gHistSSDModuleIdLayer5);//entry 0

  TH1F *gHistSSDModuleIdLayer6 = new TH1F("fHistSSDModuleIdLayer6",
					  "Module Id - Layer 6;Module Id;Entries",
					  fgkSSDMODULESLAYER6,
					  nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
					  nITSTotalModules + 0.5);
  fHistSSDArray->Add(gHistSSDModuleIdLayer6);//entry 1
  
  TH1F *gHistSSDClusterPerEventLayer5 = new TH1F("fHistSSDClusterPerEventLayer5",
						 "N_{clusters} - Layer 5;N_{clusters};Entries;",
						 100,0.1,5000);
  fHistSSDArray->Add(gHistSSDClusterPerEventLayer5);//entry 2
  
  TH1F *gHistSSDClusterPerEventLayer6 = new TH1F("fHistSSDClusterPerEventLayer6",
						 "N_{clusters} - Layer 6;N_{clusters};Entries;",
						 100,0.1,5000);
  fHistSSDArray->Add(gHistSSDClusterPerEventLayer6);//entry 3
  
  TH1F *gHistSSDLocalXLayer5 = new TH1F("fHistSSDLocalXLayer5",
					"Local x coord.- Layer 5;x [cm];Entries;",
					100,-4.,4.);
  fHistSSDArray->Add(gHistSSDLocalXLayer5);//entry 4
  
  TH1F *gHistSSDLocalXLayer6 = new TH1F("fHistSSDLocalXLayer6",
					"Local x coord.- Layer 6;x [cm];Entries;",
					100,-4.,4.);
  fHistSSDArray->Add(gHistSSDLocalXLayer6);//entry 5
  
  TH1F *gHistSSDLocalZLayer5 = new TH1F("fHistSSDLocalZLayer5",
					"Local z coord.- Layer 5;z [cm];Entries;",
					100,-4.,4.);
  fHistSSDArray->Add(gHistSSDLocalZLayer5);//entry 6
  
  TH1F *gHistSSDLocalZLayer6 = new TH1F("fHistSSDLocalZLayer6",
					"Local z coord.- Layer 6;z [cm];Entries;",
					100,-4.,4.);
  fHistSSDArray->Add(gHistSSDLocalZLayer6);//entry 7
  
  TH1F *gHistSSDGlobalXLayer5 = new TH1F("fHistSSDGlobalXLayer5",
					 "Global x - Layer 5;x [cm];Entries;",
					 100,-40.,40.);
  fHistSSDArray->Add(gHistSSDGlobalXLayer5);//entry 8
  
  TH1F *gHistSSDGlobalXLayer6 = new TH1F("fHistSSDGlobalXLayer6",
					 "Global x - Layer 6;x [cm];Entries;",
					 100,-45.,45.);
  fHistSSDArray->Add(gHistSSDGlobalXLayer6);//entry 9
  
  TH1F *gHistSSDGlobalYLayer5 = new TH1F("fHistSSDGlobalYLayer5",
					 "Global y - Layer 5;y [cm];Entries;",
					 100,-40.,40);
  fHistSSDArray->Add(gHistSSDGlobalYLayer5);//entry 10
  
  TH1F *gHistSSDGlobalYLayer6 = new TH1F("fHistSSDGlobalYLayer6",
					 "Global y - Layer 6;y [cm];Entries;",
					 100,-45.,45.);
  fHistSSDArray->Add(gHistSSDGlobalYLayer6);//entry 11
  
  TH1F *gHistSSDGlobalZLayer5 = new TH1F("fHistSSDGlobalZLayer5",
					 "Global z - Layer 5;z [cm];Entries;",
					 100,-45.,45);
  fHistSSDArray->Add(gHistSSDGlobalZLayer5);//entry 12
  
  TH1F *gHistSSDGlobalZLayer6 = new TH1F("fHistSSDGlobalZLayer6",
					 "Global z - Layer 6;z [cm];Entries;",
					 100,-55.,55.);
  fHistSSDArray->Add(gHistSSDGlobalZLayer6);//entry 13
  
  TH1F *gHistSSDPhiLayer5 = new TH1F("fHistSSDPhiLayer5",
				     "#phi - Layer 5;#phi [rad];Entries;",
				     100,-TMath::Pi(),TMath::Pi());
  fHistSSDArray->Add(gHistSSDPhiLayer5);//entry 14
  
  TH1F *gHistSSDPhiLayer6 = new TH1F("fHistSSDPhiLayer6",
				     "#phi - Layer 6;#phi [rad];Entries;",
				     100,-TMath::Pi(),TMath::Pi());
  fHistSSDArray->Add(gHistSSDPhiLayer6);//entry 15
  
  TH1F *gHistSSDThetaLayer5 = new TH1F("fHistSSDThetaLayer5",
				       "#theta - Layer 5;#theta [rad];Entries;",
				       100,-TMath::Pi(),TMath::Pi());
  fHistSSDArray->Add(gHistSSDThetaLayer5);//entry 16
  
  TH1F *gHistSSDThetaLayer6 = new TH1F("fHistSSDThetaLayer6",
				       "#theta - Layer 6;#theta [rad];Entries;",
				       100,-TMath::Pi(),TMath::Pi());
  fHistSSDArray->Add(gHistSSDThetaLayer6);//entry 17
  
  TH1F *gHistSSDRadiusLayer5 = new TH1F("fHistSSDRadiusLayer5",
					"r - Layer 5;r [cm];Entries;",
					100,35.,50.);
  fHistSSDArray->Add(gHistSSDRadiusLayer5);//entry 18
  
  TH1F *gHistSSDRadiusLayer6 = new TH1F("fHistSSDRadiusLayer6",
					"r - Layer 6;r [cm];Entries;",
					100,35.,50.);
  fHistSSDArray->Add(gHistSSDRadiusLayer6);//entry 19
  
  TH1F *gHistSSDClusterTypeLayer5 = new TH1F("Layer5/fHistSSDClusterTypeLayer5",
					     "CL type - Layer 5;Cluster type;Entries;",
					     150,0,150);
  fHistSSDArray->Add(gHistSSDClusterTypeLayer5);//entry 20
  
  TH1F *gHistSSDClusterTypeLayer6 = new TH1F("fHistSSDClusterTypeLayer6",
					     "CL type - Layer 6;Cluster type;Entries;",
					     150,0,150);
  fHistSSDArray->Add(gHistSSDClusterTypeLayer6);//entry 21
  
  TH1F *gHistSSDChargeRatioLayer5 = new TH1F("fHistSSDChargeRatioLayer5",
					     "Charge ratio - Layer 5;q_{ratio};Entries;",
					     100,-2.0,2.0);
  fHistSSDArray->Add(gHistSSDChargeRatioLayer5);//entry 22
  
  TH1F *gHistSSDChargeRatioLayer6 = new TH1F("fHistSSDChargeRatioLayer6",
					     "Charge ratio - Layer 6;q_{ratio};Entries;",
					     100,-2.0,2.0);
  fHistSSDArray->Add(gHistSSDChargeRatioLayer6);//entry 23
  
  TH1F *gHistSSDChargekeVLayer5 = new TH1F("fHistSSDChargekeVLayer5",
					   "Charge - Layer 5;q [keV];Entries;",
					   100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargekeVLayer5);//entry 24
  
  TH1F *gHistSSDChargekeVLayer6 = new TH1F("fHistSSDChargekeVLayer6",
					   "Charge - Layer 6;q [keV];Entries;",
					   100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargekeVLayer6);//entry 25
  
  TH1F *gHistSSDChargePSideLayer5 = new TH1F("fHistSSDChargePSideLayer5",
					     "Charge P- Layer 5;q_{P} [keV];Entries;",
					     100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargePSideLayer5);//entry 26
  
  TH1F *gHistSSDChargePSideLayer6 = new TH1F("fHistSSDChargePSideLayer6",
					     "Charge P- Layer 6;q_{P} [keV];Entries;",
					     100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargePSideLayer6);//entry 27
  
  TH1F *gHistSSDChargeNSideLayer5 = new TH1F("fHistSSDChargeNSideLayer5",
					     "Charge N- Layer 5;q_{N} [keV];Entries;",
					     100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargeNSideLayer5);//entry 28
  
  TH1F *gHistSSDChargeNSideLayer6 = new TH1F("fHistSSDChargeNSideLayer6",
					     "Charge N- Layer 6;q_{N} [keV];Entries;",
					     100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargeNSideLayer6);//entry 29
  
  TH1F *gHistSSDChargeRatio2Layer5 = new TH1F("fHistSSDChargeRatio2Layer5",
					      "Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
					      100,0,2);
  fHistSSDArray->Add(gHistSSDChargeRatio2Layer5);//entry 30
  
  TH1F *gHistSSDChargeRatio2Layer6 = new TH1F("fHistSSDChargeRatio2Layer6",
					      "Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
					      100,0,2);
  fHistSSDArray->Add(gHistSSDChargeRatio2Layer6);//entry 31
  
  TH2F *gHistSSDChargePNSideLayer5 = new TH2F("fHistSSDChargePNSideLayer5",
					      "Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
					      100,0.,300.,
					      100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargePNSideLayer5);//entry 32
  
  TH2F *gHistSSDChargePNSideLayer6 = new TH2F("fHistSSDChargePNSideLayer6",
					      "Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
					      100,0.,300.,
					      100,0.,300.);
  fHistSSDArray->Add(gHistSSDChargePNSideLayer6);//entry 33
  
  TH2F *gHistSSDChargeMapLayer5 = new TH2F("fHistSSDChargeMapLayer5",
					   "Charge map;N_{modules};N_{Ladders}",
					   fgkSSDMODULESPERLADDERLAYER5,
					   -0.5,fgkSSDMODULESPERLADDERLAYER5+0.5,
					   3*fgkSSDLADDERSLAYER5,
					   -0.5,fgkSSDLADDERSLAYER5+0.5);
  fHistSSDArray->Add(gHistSSDChargeMapLayer5);//entry 34
  
  TH2F *gHistSSDChargeMapLayer6 = new TH2F("fHistSSDChargeMapLayer6",
					   "Charge map;N_{modules};N_{Ladders}",
					   fgkSSDMODULESPERLADDERLAYER6,
					   -0.5,fgkSSDMODULESPERLADDERLAYER6+0.5,
					   3*fgkSSDLADDERSLAYER6,
					   -0.5,fgkSSDLADDERSLAYER6+0.5);
  fHistSSDArray->Add(gHistSSDChargeMapLayer6);//entry 35
  
  TH2F *gHistSSDClusterMapLayer5 = new TH2F("fHistSSDClusterMapLayer5",
					    "Layer 5;N_{module};N_{ladder}",
					    22,1,23,
					    34,500,534);
  gHistSSDClusterMapLayer5->GetXaxis()->SetTitleColor(1);
  gHistSSDClusterMapLayer5->SetStats(kFALSE);
  gHistSSDClusterMapLayer5->GetYaxis()->SetTitleOffset(1.8);
  gHistSSDClusterMapLayer5->GetXaxis()->SetNdivisions(22);
  gHistSSDClusterMapLayer5->GetYaxis()->SetNdivisions(34);
  gHistSSDClusterMapLayer5->GetXaxis()->SetLabelSize(0.03);
  gHistSSDClusterMapLayer5->GetYaxis()->SetLabelSize(0.03);
  gHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
  gHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
  fHistSSDArray->Add(gHistSSDClusterMapLayer5); //entry 36
  
  TH2F *gHistSSDClusterMapLayer6 = new TH2F("fHistSSDClusterMapLayer6",
					    "Layer 6;N_{module};N_{ladder}",
					    25,1,26,
					    38,600,638);
  gHistSSDClusterMapLayer6->GetXaxis()->SetTitleColor(1);
  gHistSSDClusterMapLayer6->SetStats(kFALSE);
  gHistSSDClusterMapLayer6->GetYaxis()->SetTitleOffset(1.8);
  gHistSSDClusterMapLayer6->GetXaxis()->SetNdivisions(25);
  gHistSSDClusterMapLayer6->GetYaxis()->SetNdivisions(38);
  gHistSSDClusterMapLayer6->GetXaxis()->SetLabelSize(0.03);
  gHistSSDClusterMapLayer6->GetYaxis()->SetLabelSize(0.03);
  gHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
  gHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
  fHistSSDArray->Add(gHistSSDClusterMapLayer6);//entry 37

  HLTInfo("Finished initialization of SSD histograms");  

  return 0;  
}
  
int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
  // see header file for class documentation
  if(fHistSSDArray) delete fHistSSDArray;

  return 0;
}

int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, AliHLTComponentTriggerData& /*trigData*/)
{
  
  Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;   
  
  const AliHLTComponentBlockData* iter = NULL;
  
  if(!IsDataEvent())
    return 0;
  
  for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
    
    if(iter->fDataType!=(kAliHLTAnyDataType|kAliHLTDataOriginITSSSD))
      continue;
    
    const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
    Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
    AliHLTITSSpacePointData *clusters = (AliHLTITSSpacePointData*) clusterData->fSpacePoints;
    
    for(int i = 0; i < nSpacepoint; i++) { //cluster loop
      Int_t lab[4]={0,0,0,0};
      Float_t hit[6]={0,0,0,0,0,0};
      Int_t info[3]={0,0,0};
      
      lab[0]=clusters[i].fTracks[0];
      lab[1]=clusters[i].fTracks[1];
      lab[2]=clusters[i].fTracks[2];
      lab[3]=clusters[i].fIndex;
      hit[0]=clusters[i].fY;
      hit[1]=clusters[i].fZ;
      hit[2]=clusters[i].fSigmaY2;
      hit[3]=clusters[i].fSigmaZ2;
      hit[4]=clusters[i].fQ;
      hit[5]=clusters[i].fSigmaYZ;
      info[0]=clusters[i].fNy;
      info[1]=clusters[i].fNz;
      info[2]=clusters[i].fLayer;
      
      AliITSRecPoint recp(lab,hit,info);
      
      Int_t module = 0;
      Int_t gLayer = 0, gLadder = 0, gModule = 0;
      Int_t lLadderLocationY = 0;
      
      Float_t cluglo[3]={0.,0.,0.}; 
      
      Int_t layer = recp.GetLayer();
      if (layer == 4) module = recp.GetDetectorIndex() + 500;
      if (layer == 5) module = recp.GetDetectorIndex() + 1248;
      
      AliITSgeomTGeo::GetModuleId(module,gLayer,gLadder,gModule);
      lLadderLocationY = 3*gLadder; 
      
      recp.GetGlobalXYZ(cluglo);
      Float_t radius = TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]); 
      Float_t phi = TMath::ATan2(cluglo[1],cluglo[0]);
      Float_t theta = TMath::ATan2(radius,cluglo[2]);
      Double_t chargeRatio = recp.GetChargeRatio();
      Double_t clusterCharge = recp.GetQ();
      Double_t chargePSide = clusterCharge*(1. + chargeRatio);
      Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
      
      if(layer == 4) {
	dynamic_cast<TH1F *>(fHistSSDArray->At(0))->Fill(module);
	dynamic_cast<TH1F *>(fHistSSDArray->At(4))->Fill(recp.GetDetLocalX());
	dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
	dynamic_cast<TH1F *>(fHistSSDArray->At(8))->Fill(cluglo[0]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(10))->Fill(cluglo[1]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(12))->Fill(cluglo[2]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(14))->Fill(phi);
	dynamic_cast<TH1F *>(fHistSSDArray->At(16))->Fill(theta);
	dynamic_cast<TH1F *>(fHistSSDArray->At(18))->Fill(radius);
	dynamic_cast<TH1F *>(fHistSSDArray->At(20))->Fill(recp.GetType());
	dynamic_cast<TH1F *>(fHistSSDArray->At(22))->Fill(recp.GetChargeRatio());
	dynamic_cast<TH1F *>(fHistSSDArray->At(24))->Fill(recp.GetQ());
	dynamic_cast<TH1F *>(fHistSSDArray->At(26))->Fill(chargePSide);
	dynamic_cast<TH1F *>(fHistSSDArray->At(28))->Fill(chargeNSide);
	if(chargePSide != 0.)
	  dynamic_cast<TH1F *>(fHistSSDArray->At(30))->Fill(chargeNSide/chargePSide);
	dynamic_cast<TH2F *>(fHistSSDArray->At(32))->Fill(chargePSide,
							  chargeNSide);
	dynamic_cast<TH2F *>(fHistSSDArray->At(34))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
	dynamic_cast<TH2F *>(fHistSSDArray->At(36))->Fill(gModule,499+gLadder,1);
	nClustersLayer5 += 1;
      }//layer 5 histograms
      if(layer == 5) {
	dynamic_cast<TH1F *>(fHistSSDArray->At(1))->Fill(module);
	dynamic_cast<TH1F *>(fHistSSDArray->At(5))->Fill(recp.GetDetLocalX());
	dynamic_cast<TH1F *>(fHistSSDArray->At(6))->Fill(recp.GetDetLocalZ());
	dynamic_cast<TH1F *>(fHistSSDArray->At(9))->Fill(cluglo[0]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(11))->Fill(cluglo[1]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(13))->Fill(cluglo[2]);
	dynamic_cast<TH1F *>(fHistSSDArray->At(15))->Fill(phi);
	dynamic_cast<TH1F *>(fHistSSDArray->At(17))->Fill(theta);
	dynamic_cast<TH1F *>(fHistSSDArray->At(19))->Fill(radius);
	dynamic_cast<TH1F *>(fHistSSDArray->At(21))->Fill(recp.GetType());
	dynamic_cast<TH1F *>(fHistSSDArray->At(23))->Fill(recp.GetChargeRatio());
	dynamic_cast<TH1F *>(fHistSSDArray->At(25))->Fill(recp.GetQ());
	dynamic_cast<TH1F *>(fHistSSDArray->At(27))->Fill(chargePSide);
	dynamic_cast<TH1F *>(fHistSSDArray->At(29))->Fill(chargeNSide);
	if(chargePSide != 0.)
	  dynamic_cast<TH1F *>(fHistSSDArray->At(31))->Fill(chargeNSide/chargePSide);
	dynamic_cast<TH2F *>(fHistSSDArray->At(33))->Fill(chargePSide,
							  chargeNSide);
	dynamic_cast<TH2F *>(fHistSSDArray->At(35))->SetBinContent(gModule,lLadderLocationY,recp.GetQ());
	dynamic_cast<TH2F *>(fHistSSDArray->At(37))->Fill(gModule,599+gLadder,1);
	nClustersLayer6 += 1;
      }//layer 6 histograms
    }//cluster loop
    dynamic_cast<TH1F *>(fHistSSDArray->At(2))->Fill(nClustersLayer5);
    dynamic_cast<TH1F *>(fHistSSDArray->At(3))->Fill(nClustersLayer6);
 }//input block
 
 //Publish array
 AliHLTUInt32_t fSpecification = 0x0;
 PushBack( (TObjArray*) fHistSSDArray,kAliHLTDataTypeTObjArray|kAliHLTDataOriginITSSSD,fSpecification);
 
 HLTInfo("ITSSSDQARecPoints found %d SSD clusters", nClustersLayer5+nClustersLayer6);

 return 0;
}
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
	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"
4b1ad1e4	37	#include "TH1.h"
4b1ad1e4	38	#include "TH2.h"
fd091d74	39	#include "AliITSgeomTGeo.h"
b5284ba2	40	#include "AliGeomManager.h"
fd091d74	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(),
4b1ad1e4	50	fHistSSDArray(NULL) {
fd091d74	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
4b1ad1e4	99	int AliHLTITSSSDQARecPointsComponent::DoInit(int /argc/, const char** /argv/) {
fd091d74	100	//Inititalization of histograms for the SSD QA component
b5284ba2	101
	102
	103	if(AliGeomManager::GetGeometry()==NULL){
	104	AliGeomManager::LoadGeometry();
	105	}
	106
	107
4b1ad1e4	108	fHistSSDArray = new TObjArray();
4b1ad1e4	109	fHistSSDArray->SetName("ssdArray");
fd091d74	110
	111	Int_t nModuleOffset = 500;
	112	Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
4b1ad1e4	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
fd091d74	334
	335	HLTInfo("Finished initialization of SSD histograms");
	336
4b1ad1e4	337	return 0;
fd091d74	338	}
	339
	340	int AliHLTITSSSDQARecPointsComponent::DoDeinit() {
	341	// see header file for class documentation
4b1ad1e4	342	if(fHistSSDArray) delete fHistSSDArray;
4b1ad1e4	343
fd091d74	344	return 0;
	345	}
	346
	347	int AliHLTITSSSDQARecPointsComponent::DoEvent(const AliHLTComponentEventData& /evtData/, AliHLTComponentTriggerData& /trigData/)
	348	{
	349
4b1ad1e4	350	Int_t nClustersLayer5 = 0, nClustersLayer6 = 0;
4b1ad1e4	351
fd091d74	352	const AliHLTComponentBlockData* iter = NULL;
	353
	354	if(!IsDataEvent())
	355	return 0;
4b1ad1e4	356
4b1ad1e4	357	for ( iter = GetFirstInputBlock(kAliHLTDataTypeClusters); iter != NULL; iter = GetNextInputBlock() ) {
fd091d74	358
fd091d74	359	if(iter->fDataType!=(kAliHLTAnyDataType\|kAliHLTDataOriginITSSSD))
4b1ad1e4	360	continue;
4b1ad1e4	361
fd091d74	362	const AliHLTITSClusterData* clusterData = (const AliHLTITSClusterData*) iter->fPtr;
fd091d74	363	Int_t nSpacepoint = (Int_t) clusterData->fSpacePointCnt;
fd091d74	364	AliHLTITSSpacePointData clusters = (AliHLTITSSpacePointData) clusterData->fSpacePoints;
4b1ad1e4	365
4b1ad1e4	366	for(int i = 0; i < nSpacepoint; i++) { //cluster loop
fd091d74	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;
4b1ad1e4	384
fd091d74	385	AliITSRecPoint recp(lab,hit,info);
fd091d74	386
4b1ad1e4	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
fd091d74	409	if(layer == 4) {
4b1ad1e4	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);
fd091d74	430	nClustersLayer5 += 1;
	431	}//layer 5 histograms
	432	if(layer == 5) {
4b1ad1e4	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);
fd091d74	453	nClustersLayer6 += 1;
	454	}//layer 6 histograms
	455	}//cluster loop
4b1ad1e4	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);
fd091d74	465
4b1ad1e4	466	return 0;
fd091d74	467	}