[u/mrichter/AliRoot.git] / ITS / AliITSQASSDDataMakerSim.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * 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.                  *
 **************************************************************************/

/* $Id$   */

//  *************************************************************
//  Checks the quality assurance 
//  by comparing with reference data
//  contained in a DB
//  -------------------------------------------------------------
//  W. Ferrarese + P. Cerello Feb 2008
//  INFN Torino
//  SSD QA part: P. Christakoglou - NIKHEF/UU

// --- ROOT system ---
#include <TTree.h>
#include <TH1.h>
#include <TH2.h>
#include <TMath.h>
// --- Standard library ---

// --- AliRoot header files ---
#include "AliITS.h"
#include "AliITSmodule.h"
#include "AliITShit.h"
#include "AliITSdigit.h"
#include "AliITSpListItem.h"
#include "AliRun.h"
#include "AliITSQADataMakerSim.h"
#include "AliITSQASSDDataMakerSim.h"
#include "AliLog.h"
#include "AliQA.h"
#include "AliQAChecker.h"
#include "AliRawReader.h"

ClassImp(AliITSQASSDDataMakerSim)

//____________________________________________________________________________ 
AliITSQASSDDataMakerSim::AliITSQASSDDataMakerSim(AliITSQADataMakerSim *aliITSQADataMakerSim) :
TObject(),
fAliITSQADataMakerSim(aliITSQADataMakerSim),
fSSDhDigits(0),
fSSDhSDigits(0),
fSSDhHits(0),
fGenOffset(0) {
  //ctor used to discriminate OnLine-Offline analysis   
}

//____________________________________________________________________________ 
AliITSQASSDDataMakerSim::AliITSQASSDDataMakerSim(const AliITSQASSDDataMakerSim& qadm) :
TObject(),
fAliITSQADataMakerSim(qadm.fAliITSQADataMakerSim),
fSSDhDigits(qadm.fSSDhDigits),
fSSDhSDigits(qadm.fSSDhSDigits),
fSSDhHits(qadm.fSSDhHits),
fGenOffset(qadm.fGenOffset) {
  //copy ctor 
  fAliITSQADataMakerSim->SetName((const char*)qadm.fAliITSQADataMakerSim->GetName()) ; 
  fAliITSQADataMakerSim->SetTitle((const char*)qadm.fAliITSQADataMakerSim->GetTitle());
  }

//__________________________________________________________________
AliITSQASSDDataMakerSim& AliITSQASSDDataMakerSim::operator = (const AliITSQASSDDataMakerSim& qac ) {
  // Equal operator.
  this->~AliITSQASSDDataMakerSim();
  new(this) AliITSQASSDDataMakerSim(qac);
  return *this;
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerSim::StartOfDetectorCycle() {
  //Detector specific actions at start of cycle
  AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list) {
  // launch the QA checking
  AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n"); 
  
  AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerSim::InitDigits() { 
  // Initialization for DIGIT data - SSD -
  fGenOffset = (fAliITSQADataMakerSim->fDigitsQAList)->GetEntries();

  // custom code here
  TH1F *fHistSSDModule = new TH1F("fHistSSDDigitsModule",
				  ";SSD Module Number;N_{DIGITS}",
				  1698,499.5,2197.5);  
  fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModule,
					fGenOffset + fSSDhDigits);
  fSSDhDigits += 1;
  TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
				       ";N_{Strip};N_{Module}",
				       1540,0,1540,1698,499.5,2197.5);  
  fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModuleStrip,
					fGenOffset + fSSDhDigits);
  fSSDhDigits += 1;

  AliDebug(1,Form("%d SSD Digits histograms booked\n",fSSDhDigits));

}

//____________________________________________________________________________
void AliITSQASSDDataMakerSim::MakeDigits(TTree *digits) { 
  // Fill QA for DIGIT - SSD -
  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
  fITS->SetTreeAddress();
  TClonesArray *iSSDdigits  = fITS->DigitsAddress(2);
  for(Int_t iModule = 500; iModule < 2198; iModule++) {
    iSSDdigits->Clear();
    digits->GetEvent(iModule);    
    Int_t ndigits = iSSDdigits->GetEntries();
    fAliITSQADataMakerSim->GetDigitsData(fGenOffset + 0)->Fill(iModule,ndigits);
    if(ndigits != 0)
      AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));
 
    for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
      AliITSdigit *dig = (AliITSdigit*)iSSDdigits->UncheckedAt(iDigit);
      Int_t fStripNumber = (dig->GetCoord1() == 0) ? dig->GetCoord2() : dig->GetCoord2() + fgkNumberOfPSideStrips;
      ((TH2F *)fAliITSQADataMakerSim->GetDigitsData(fGenOffset + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
    }//digit loop
  }//module loop
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerSim::InitSDigits() { 
  // Initialization for SDIGIT data - SSD -
  fGenOffset = (fAliITSQADataMakerSim->fSDigitsQAList)->GetEntries();

  // custom code here
  TH1F *fHistSSDModule = new TH1F("fHistSSDSDigitsModule",
				  ";SSD Module Number;N_{SDIGITS}",
				  1698,499.5,2197.5);  
  fAliITSQADataMakerSim->Add2SDigitsList(fHistSSDModule,
					 fGenOffset + fSSDhSDigits);
  fSSDhSDigits += 1;  

  AliDebug(1,Form("%d SSD SDigits histograms booked\n",fSSDhSDigits));
}

//____________________________________________________________________________
void AliITSQASSDDataMakerSim::MakeSDigits(TTree *sdigits) { 
  // Fill QA for SDIGIT - SSD -
  static TClonesArray iSSDEmpty("AliITSpListItem",10000);
  iSSDEmpty.Clear();
  TClonesArray *iSSDsdigits = &iSSDEmpty;

  TBranch *brchSDigits = sdigits->GetBranch("ITS");
  brchSDigits->SetAddress(&iSSDsdigits);
  for(Int_t iModule = 500; iModule < 2198; iModule++) {
    iSSDsdigits->Clear();
    sdigits->GetEvent(iModule);    
    Int_t ndigits = iSSDsdigits->GetEntries();
    fAliITSQADataMakerSim->GetSDigitsData(fGenOffset + 0)->Fill(iModule,ndigits);
    if(ndigits != 0)
      AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));

    for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
      AliITSpListItem *dig=(AliITSpListItem*)iSSDsdigits->At(iDigit);
      dig=0;
    }//digit loop
  }//module loop
}

//____________________________________________________________________________ 
void AliITSQASSDDataMakerSim::InitHits() { 
  // Initialization for HITS data - SSD -
  fGenOffset = (fAliITSQADataMakerSim->fHitsQAList)->GetEntries();

  // custom code here
  TH1F *fHistSSDModule = new TH1F("fHistSSDHitsModule",
				  ";SDD Module Number;N_{HITS}",
				  1698,499.5,2197.5); 
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDModule,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDGlobalX = new TH1F("fHistSSDHitsGlobalX",
				   ";x [cm];Entries",
				   1000,-50.,50.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalX,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDGlobalY = new TH1F("fHistSSDHitsGlobalY",
				   ";y [cm];Entries",
				   1000,-50.,50.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalY,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDGlobalZ = new TH1F("fHistSSDHitsGlobalZ",
				   ";z [cm];Entries",
				   1000,-60.,60.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalZ,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDLocalX = new TH1F("fHistSSDHitsLocalX",
				  ";x [cm];Entries",
				  1000,-4.,4.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalX,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDLocalY = new TH1F("fHistSSDHitsLocalY",
				  ";y [cm];Entries",
				  1000,-0.1,0.1);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalY,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDLocalZ = new TH1F("fHistSSDHitsLocalZ",
				  ";z [cm];Entries",
				  1000,-4.,4.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalZ,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH1F *fHistSSDIonization = new TH1F("fHistSSDHitsIonization",
				      ";log(dE/dx) [KeV];N_{Hits}",
				      100,-7,-2);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDIonization,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
  TH2F *fHistSSDGlobalXY = new TH2F("fHistSSDHitsGlobalXY",
				    ";x [cm];y [cm]",
				    1000,-50.,50.,
				    1000,-50.,50.);
  fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalXY,
				      fGenOffset + fSSDhHits);
  fSSDhHits += 1;
 
  AliDebug(1,Form("%d SSD Hits histograms booked\n",fSSDhHits));
}


//____________________________________________________________________________
void AliITSQASSDDataMakerSim::MakeHits(TTree *hits) { 
  // Fill QA for HITS - SSD -
  AliITS *fITS  = (AliITS*)gAlice->GetModule("ITS");
  fITS->SetTreeAddress();
  Int_t nmodules;
  fITS->InitModules(-1,nmodules);
  fITS->FillModules(hits,0);
  for(Int_t iModule = 500; iModule < 2198; iModule++) {
    AliITSmodule *module = fITS->GetModule(iModule);
    TObjArray *arrHits = module->GetHits();
    Int_t nhits = arrHits->GetEntriesFast();
    if(nhits != 0)
      AliDebug(1,Form("Module: %d - Hits: %d",iModule,nhits));
    for (Int_t iHit = 0; iHit < nhits; iHit++) {
      AliITShit *hit = (AliITShit*) arrHits->At(iHit);
      
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 0)->Fill(iModule);
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 1)->Fill(hit->GetXG());
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 2)->Fill(hit->GetYG());
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 3)->Fill(hit->GetZG());
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 4)->Fill(hit->GetXL());
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 5)->Fill(hit->GetYL());
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 6)->Fill(hit->GetZL());
      if(hit->GetIonization())
	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 7)->Fill(TMath::Log10(hit->GetIonization()));
      fAliITSQADataMakerSim->GetHitsData(fGenOffset + 8)->Fill(hit->GetXG(),hit->GetYG());
    }//hit loop
  }//module loop  
}
Commit	Line	Data
83c81861	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	// *************************************************************
	19	// Checks the quality assurance
	20	// by comparing with reference data
	21	// contained in a DB
	22	// -------------------------------------------------------------
	23	// W. Ferrarese + P. Cerello Feb 2008
	24	// INFN Torino
	25	// SSD QA part: P. Christakoglou - NIKHEF/UU
	26
	27	// --- ROOT system ---
	28	#include <TTree.h>
	29	#include <TH1.h>
	30	#include <TH2.h>
	31	#include <TMath.h>
	32	// --- Standard library ---
	33
	34	// --- AliRoot header files ---
	35	#include "AliITS.h"
	36	#include "AliITSmodule.h"
	37	#include "AliITShit.h"
	38	#include "AliITSdigit.h"
	39	#include "AliITSpListItem.h"
	40	#include "AliRun.h"
	41	#include "AliITSQADataMakerSim.h"
	42	#include "AliITSQASSDDataMakerSim.h"
	43	#include "AliLog.h"
	44	#include "AliQA.h"
	45	#include "AliQAChecker.h"
	46	#include "AliRawReader.h"
	47
	48	ClassImp(AliITSQASSDDataMakerSim)
	49
	50	//____________________________________________________________________________
	51	AliITSQASSDDataMakerSim::AliITSQASSDDataMakerSim(AliITSQADataMakerSim *aliITSQADataMakerSim) :
	52	TObject(),
	53	fAliITSQADataMakerSim(aliITSQADataMakerSim),
	54	fSSDhDigits(0),
	55	fSSDhSDigits(0),
	56	fSSDhHits(0),
	57	fGenOffset(0) {
	58	//ctor used to discriminate OnLine-Offline analysis
	59	}
	60
	61	//____________________________________________________________________________
	62	AliITSQASSDDataMakerSim::AliITSQASSDDataMakerSim(const AliITSQASSDDataMakerSim& qadm) :
	63	TObject(),
	64	fAliITSQADataMakerSim(qadm.fAliITSQADataMakerSim),
65	fSSDhDigits(qadm.fSSDhDigits),
66	fSSDhSDigits(qadm.fSSDhSDigits),
67	fSSDhHits(qadm.fSSDhHits),
68	fGenOffset(qadm.fGenOffset) {
69	//copy ctor
70	fAliITSQADataMakerSim->SetName((const char*)qadm.fAliITSQADataMakerSim->GetName()) ;
71	fAliITSQADataMakerSim->SetTitle((const char*)qadm.fAliITSQADataMakerSim->GetTitle());
72	}
73
74	//__________________________________________________________________
75	AliITSQASSDDataMakerSim& AliITSQASSDDataMakerSim::operator = (const AliITSQASSDDataMakerSim& qac ) {
76	// Equal operator.
77	this->~AliITSQASSDDataMakerSim();
78	new(this) AliITSQASSDDataMakerSim(qac);
79	return *this;
80	}
81
82	//____________________________________________________________________________
83	void AliITSQASSDDataMakerSim::StartOfDetectorCycle() {
84	//Detector specific actions at start of cycle
85	AliDebug(1,"AliITSQADM::Start of SSD Cycle\n");
86	}
87
88	//____________________________________________________________________________
89	void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray* list) {
90	// launch the QA checking
91	AliDebug(1,"AliITSDM instantiates checker with Run(AliQA::kITS, task, list)\n");
92
93	AliQAChecker::Instance()->Run( AliQA::kITS , task, list);
94	}
95
96	//____________________________________________________________________________
97	void AliITSQASSDDataMakerSim::InitDigits() {
98	// Initialization for DIGIT data - SSD -
99	fGenOffset = (fAliITSQADataMakerSim->fDigitsQAList)->GetEntries();
100
101	// custom code here
102	TH1F *fHistSSDModule = new TH1F("fHistSSDDigitsModule",
103	";SSD Module Number;N_{DIGITS}",
104	1698,499.5,2197.5);
105	fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModule,
106	fGenOffset + fSSDhDigits);
107	fSSDhDigits += 1;
108	TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
109	";N_{Strip};N_{Module}",
110	1540,0,1540,1698,499.5,2197.5);
111	fAliITSQADataMakerSim->Add2DigitsList(fHistSSDModuleStrip,
112	fGenOffset + fSSDhDigits);
113	fSSDhDigits += 1;
114
115	AliDebug(1,Form("%d SSD Digits histograms booked\n",fSSDhDigits));
116
117	}
118
119	//____________________________________________________________________________
120	void AliITSQASSDDataMakerSim::MakeDigits(TTree *digits) {
121	// Fill QA for DIGIT - SSD -
122	AliITS fITS = (AliITS)gAlice->GetModule("ITS");
123	fITS->SetTreeAddress();
124	TClonesArray *iSSDdigits = fITS->DigitsAddress(2);
125	for(Int_t iModule = 500; iModule < 2198; iModule++) {
126	iSSDdigits->Clear();
127	digits->GetEvent(iModule);
128	Int_t ndigits = iSSDdigits->GetEntries();
129	fAliITSQADataMakerSim->GetDigitsData(fGenOffset + 0)->Fill(iModule,ndigits);
130	if(ndigits != 0)
131	AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));
132
133	for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
134	AliITSdigit dig = (AliITSdigit)iSSDdigits->UncheckedAt(iDigit);
135	Int_t fStripNumber = (dig->GetCoord1() == 0) ? dig->GetCoord2() : dig->GetCoord2() + fgkNumberOfPSideStrips;
136	((TH2F *)fAliITSQADataMakerSim->GetDigitsData(fGenOffset + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
137	}//digit loop
138	}//module loop
139	}
140
141	//____________________________________________________________________________
142	void AliITSQASSDDataMakerSim::InitSDigits() {
143	// Initialization for SDIGIT data - SSD -
144	fGenOffset = (fAliITSQADataMakerSim->fSDigitsQAList)->GetEntries();
145
146	// custom code here
147	TH1F *fHistSSDModule = new TH1F("fHistSSDSDigitsModule",
148	";SSD Module Number;N_{SDIGITS}",
149	1698,499.5,2197.5);
150	fAliITSQADataMakerSim->Add2SDigitsList(fHistSSDModule,
151	fGenOffset + fSSDhSDigits);
152	fSSDhSDigits += 1;
153
154	AliDebug(1,Form("%d SSD SDigits histograms booked\n",fSSDhSDigits));
155	}
156
157	//____________________________________________________________________________
158	void AliITSQASSDDataMakerSim::MakeSDigits(TTree *sdigits) {
159	// Fill QA for SDIGIT - SSD -
160	static TClonesArray iSSDEmpty("AliITSpListItem",10000);
161	iSSDEmpty.Clear();
162	TClonesArray *iSSDsdigits = &iSSDEmpty;
163
164	TBranch *brchSDigits = sdigits->GetBranch("ITS");
165	brchSDigits->SetAddress(&iSSDsdigits);
166	for(Int_t iModule = 500; iModule < 2198; iModule++) {
167	iSSDsdigits->Clear();
168	sdigits->GetEvent(iModule);
169	Int_t ndigits = iSSDsdigits->GetEntries();
170	fAliITSQADataMakerSim->GetSDigitsData(fGenOffset + 0)->Fill(iModule,ndigits);
171	if(ndigits != 0)
172	AliDebug(1,Form("Module: %d - Digits: %d",iModule,ndigits));
173
174	for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
175	AliITSpListItem dig=(AliITSpListItem)iSSDsdigits->At(iDigit);
176	dig=0;
177	}//digit loop
178	}//module loop
179	}
180
181	//____________________________________________________________________________
182	void AliITSQASSDDataMakerSim::InitHits() {
183	// Initialization for HITS data - SSD -
184	fGenOffset = (fAliITSQADataMakerSim->fHitsQAList)->GetEntries();
185
186	// custom code here
187	TH1F *fHistSSDModule = new TH1F("fHistSSDHitsModule",
188	";SDD Module Number;N_{HITS}",
189	1698,499.5,2197.5);
190	fAliITSQADataMakerSim->Add2HitsList(fHistSSDModule,
191	fGenOffset + fSSDhHits);
192	fSSDhHits += 1;
193	TH1F *fHistSSDGlobalX = new TH1F("fHistSSDHitsGlobalX",
194	";x [cm];Entries",
195	1000,-50.,50.);
196	fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalX,
197	fGenOffset + fSSDhHits);
198	fSSDhHits += 1;
199	TH1F *fHistSSDGlobalY = new TH1F("fHistSSDHitsGlobalY",
200	";y [cm];Entries",
201	1000,-50.,50.);
202	fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalY,
203	fGenOffset + fSSDhHits);
204	fSSDhHits += 1;
205	TH1F *fHistSSDGlobalZ = new TH1F("fHistSSDHitsGlobalZ",
206	";z [cm];Entries",
207	1000,-60.,60.);
208	fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalZ,
209	fGenOffset + fSSDhHits);
210	fSSDhHits += 1;
211	TH1F *fHistSSDLocalX = new TH1F("fHistSSDHitsLocalX",
212	";x [cm];Entries",
213	1000,-4.,4.);
214	fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalX,
215	fGenOffset + fSSDhHits);
216	fSSDhHits += 1;
217	TH1F *fHistSSDLocalY = new TH1F("fHistSSDHitsLocalY",
218	";y [cm];Entries",
219	1000,-0.1,0.1);
220	fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalY,
221	fGenOffset + fSSDhHits);
222	fSSDhHits += 1;
223	TH1F *fHistSSDLocalZ = new TH1F("fHistSSDHitsLocalZ",
224	";z [cm];Entries",
225	1000,-4.,4.);
226	fAliITSQADataMakerSim->Add2HitsList(fHistSSDLocalZ,
227	fGenOffset + fSSDhHits);
228	fSSDhHits += 1;
229	TH1F *fHistSSDIonization = new TH1F("fHistSSDHitsIonization",
230	";log(dE/dx) [KeV];N_{Hits}",
231	100,-7,-2);
232	fAliITSQADataMakerSim->Add2HitsList(fHistSSDIonization,
233	fGenOffset + fSSDhHits);
234	fSSDhHits += 1;
235	TH2F *fHistSSDGlobalXY = new TH2F("fHistSSDHitsGlobalXY",
236	";x [cm];y [cm]",
237	1000,-50.,50.,
238	1000,-50.,50.);
239	fAliITSQADataMakerSim->Add2HitsList(fHistSSDGlobalXY,
240	fGenOffset + fSSDhHits);
241	fSSDhHits += 1;
242
243	AliDebug(1,Form("%d SSD Hits histograms booked\n",fSSDhHits));
244	}
245
246
247	//____________________________________________________________________________
248	void AliITSQASSDDataMakerSim::MakeHits(TTree *hits) {
249	// Fill QA for HITS - SSD -
250	AliITS fITS = (AliITS)gAlice->GetModule("ITS");
251	fITS->SetTreeAddress();
252	Int_t nmodules;
253	fITS->InitModules(-1,nmodules);
254	fITS->FillModules(hits,0);
255	for(Int_t iModule = 500; iModule < 2198; iModule++) {
256	AliITSmodule *module = fITS->GetModule(iModule);
257	TObjArray *arrHits = module->GetHits();
258	Int_t nhits = arrHits->GetEntriesFast();
259	if(nhits != 0)
260	AliDebug(1,Form("Module: %d - Hits: %d",iModule,nhits));
261	for (Int_t iHit = 0; iHit < nhits; iHit++) {
262	AliITShit hit = (AliITShit) arrHits->At(iHit);
263
264	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 0)->Fill(iModule);
265	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 1)->Fill(hit->GetXG());
266	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 2)->Fill(hit->GetYG());
267	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 3)->Fill(hit->GetZG());
268	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 4)->Fill(hit->GetXL());
269	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 5)->Fill(hit->GetYL());
270	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 6)->Fill(hit->GetZL());
271	if(hit->GetIonization())
272	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 7)->Fill(TMath::Log10(hit->GetIonization()));
273	fAliITSQADataMakerSim->GetHitsData(fGenOffset + 8)->Fill(hit->GetXG(),hit->GetYG());
274	}//hit loop
275	}//module loop
276	}