[u/mrichter/AliRoot.git] / CORRFW / AliCFSingleTrackTask.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, 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.                  *
 **************************************************************************/

//-----------------------------------------------------------------------
// Example of task running on AliEn (CAF?)
// which provides standard way of calculating acceptance and efficiency
// between different steps of the procedure.
// The ouptut of the task is a AliCFContainer from which the efficiencies
// can be calculated
//-----------------------------------------------------------------------
// Author : R. Vernet, Consorzio Cometa - Catania (it)
//-----------------------------------------------------------------------


#ifndef ALICFSINGLETRACKTASK_CXX
#define ALICFSINGLETRACKTASK_CXX
#include <TROOT.h>
#include <TInterpreter.h>

#include "AliCFSingleTrackTask.h"
#include "TCanvas.h"
#include "AliStack.h"
#include "TParticle.h"
#include "TH1I.h"
#include "TChain.h"
#include "AliMCEventHandler.h"
#include "AliMCEvent.h"
#include "AliAnalysisManager.h"
#include "AliESDEvent.h"
#include "AliCFManager.h"
#include "AliCFCutBase.h"
#include "AliCFContainer.h"
#include "TChain.h"
#include "AliESDtrack.h"
#include "AliLog.h"
ClassImp(AliCFSingleTrackTask)
//__________________________________________________________________________
AliCFSingleTrackTask::AliCFSingleTrackTask() :
  fChain(0x0),
  fESD(0x0),
  fCFManager(0x0),
  fQAHistList(0x0),
  fHistEventsProcessed(0x0)
{
//Defual ctor
}
//___________________________________________________________________________
AliCFSingleTrackTask::AliCFSingleTrackTask(const Char_t* name) :
  AliAnalysisTask(name,"AliCFSingleTrackTask"),
  fChain(0x0),
  fESD(0x0),
  fCFManager(0x0),
  fQAHistList(0x0),
  fHistEventsProcessed(0x0)
{
  //
  // Constructor. Initialization of Inputs and Outputs
  //
  Info("AliCFSingleTrackTask","Calling Constructor");
  DefineInput (0,TChain::Class());
  DefineOutput(0,TH1I::Class());
  DefineOutput(1,AliCFContainer::Class());
  DefineOutput(2,TList::Class());
}

//___________________________________________________________________________
AliCFSingleTrackTask& AliCFSingleTrackTask::operator=(const AliCFSingleTrackTask& c) 
{
  //
  // Assignment operator
  //
  if (this!=&c) {
    AliAnalysisTask::operator=(c) ;
    fChain      = c.fChain;
    fESD        = c.fESD;
    fCFManager  = c.fCFManager;
    fQAHistList = c.fQAHistList ;
    fHistEventsProcessed = c.fHistEventsProcessed;
  }
  return *this;
}

//___________________________________________________________________________
AliCFSingleTrackTask::AliCFSingleTrackTask(const AliCFSingleTrackTask& c) :
  AliAnalysisTask(c),
  fChain(c.fChain),
  fESD(c.fESD),
  fCFManager(c.fCFManager),
  fQAHistList(c.fQAHistList),
  fHistEventsProcessed(c.fHistEventsProcessed)
{
  //
  // Copy Constructor
  //
}

//___________________________________________________________________________
AliCFSingleTrackTask::~AliCFSingleTrackTask() {
  //
  //destructor
  //
  Info("~AliCFSingleTrackTask","Calling Destructor");
  if (fChain)               delete fChain ;
  if (fESD)                 delete fESD ;
  if (fCFManager)           delete fCFManager ;
  if (fHistEventsProcessed) delete fHistEventsProcessed ;
  if (fQAHistList) {fQAHistList->Clear(); delete fQAHistList;}
}

//___________________________________________________________________________

void AliCFSingleTrackTask::Init()
{

}
//_________________________________________________
void AliCFSingleTrackTask::Exec(Option_t *)
{
  //
  // Main loop function
  //
  Info("Exec","") ;
  // Get the mc truth
  AliMCEventHandler* mcTruth = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());

  if (!mcTruth) Error("Exec","NO MC INFO FOUND... EXITING\n");

  // transform possible old AliESD into AliESDEvent

  if (fESD->GetAliESDOld()) fESD->CopyFromOldESD(); //transition to new ESD format

  //pass the MC evt handler to the cuts that need it 

  fCFManager->SetEventInfo(mcTruth);

  // Get the MC event 
  AliMCEvent* mcEvent = mcTruth->MCEvent();

  // MC-event selection
  Float_t containerInput[2] ;
        
  //loop on the MC event
  for (Int_t ipart=0; ipart<mcEvent->GetNumberOfTracks(); ipart++) { 
    AliMCParticle *mcPart  = mcEvent->GetTrack(ipart);

    //check the MC-level cuts
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;

    containerInput[0] = (Float_t)mcPart->Pt();
    containerInput[1] = mcPart->Eta() ;
    //fill the container for Gen-level selection
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepGenerated);
    
    //check the Acceptance-level cuts
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcPart)) continue;
    //fill the container for Acceptance-level selection
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructible);
  }    

  //Now go to rec level
  for (Int_t iTrack = 0; iTrack<fESD->GetNumberOfTracks(); iTrack++) {

    AliESDtrack* track = fESD->GetTrack(iTrack);
    
    fCFManager->FillQABeforeParticleCuts(AliCFManager::kPartRecCuts,track);  
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,track)) continue;
    fCFManager->FillQAAfterParticleCuts(AliCFManager::kPartRecCuts,track);

    // is track associated to particle ?
    if (track->GetLabel()<0) continue;
    AliMCParticle *mcPart  = mcEvent->GetTrack(track->GetLabel());
    
    // check if this track was part of the signal
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue; 
    
    //fill the container
    Double_t mom[3];
    track->GetPxPyPz(mom);
    Double_t pt=TMath::Sqrt(mom[0]*mom[0]+mom[1]*mom[1]);
    containerInput[0] = pt ;
    containerInput[1] = track->Eta();
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructed) ;   
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,track)) continue ;
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepSelected);
  }
  
  fHistEventsProcessed->Fill(0);
  PostData(0,fHistEventsProcessed) ;
  PostData(1,fCFManager->GetParticleContainer()) ;
  PostData(2,fQAHistList) ;
}


//___________________________________________________________________________
void AliCFSingleTrackTask::Terminate(Option_t*)
{
  // The Terminate() function is the last function to be called during
  // a query. It always runs on the client, it can be used to present
  // the results graphically or save the results to file.

  Info("Terminate","");
  AliAnalysisTask::Terminate();


  Double_t max1 = fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetMaximum();
  Double_t max2 = fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetMaximum();

  fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetYaxis()->SetRangeUser(0,max1*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(0,1)->GetYaxis()->SetRangeUser(0,max1*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(0,2)->GetYaxis()->SetRangeUser(0,max1*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(0,3)->GetYaxis()->SetRangeUser(0,max1*1.2);

  fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetYaxis()->SetRangeUser(0,max2*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(1,1)->GetYaxis()->SetRangeUser(0,max2*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(1,2)->GetYaxis()->SetRangeUser(0,max2*1.2);
  fCFManager->GetParticleContainer()->ShowProjection(1,3)->GetYaxis()->SetRangeUser(0,max2*1.2);

  fCFManager->GetParticleContainer()->ShowProjection(0,0)->SetMarkerStyle(23) ;
  fCFManager->GetParticleContainer()->ShowProjection(0,1)->SetMarkerStyle(24) ;
  fCFManager->GetParticleContainer()->ShowProjection(0,2)->SetMarkerStyle(25) ;
  fCFManager->GetParticleContainer()->ShowProjection(0,3)->SetMarkerStyle(26) ;

  fCFManager->GetParticleContainer()->ShowProjection(1,0)->SetMarkerStyle(23) ;
  fCFManager->GetParticleContainer()->ShowProjection(1,1)->SetMarkerStyle(24) ;
  fCFManager->GetParticleContainer()->ShowProjection(1,2)->SetMarkerStyle(25) ;
  fCFManager->GetParticleContainer()->ShowProjection(1,3)->SetMarkerStyle(26) ;

  TCanvas * c =new TCanvas("c","",1400,800);
  c->Divide(4,2);

//   TCanvas * c1 =new TCanvas("c1","",600,400);
  c->cd(1);
  fCFManager->GetParticleContainer()->ShowProjection(0,0)->Draw("p");
  c->cd(2);
  fCFManager->GetParticleContainer()->ShowProjection(0,1)->Draw("p");
  c->cd(3);
  fCFManager->GetParticleContainer()->ShowProjection(0,2)->Draw("p");
  c->cd(4);
  fCFManager->GetParticleContainer()->ShowProjection(0,3)->Draw("p");

//   TCanvas * c2 =new TCanvas("c2","",600,400);
  c->cd(5);
  fCFManager->GetParticleContainer()->ShowProjection(1,0)->Draw("p");
  c->cd(6);
  fCFManager->GetParticleContainer()->ShowProjection(1,1)->Draw("p");
  c->cd(7);
  fCFManager->GetParticleContainer()->ShowProjection(1,2)->Draw("p");
  c->cd(8);
  fCFManager->GetParticleContainer()->ShowProjection(1,3)->Draw("p");

  c->SaveAs("plots.eps");

  delete fHistEventsProcessed ;
}

//___________________________________________________________________________
void AliCFSingleTrackTask::ConnectInputData(Option_t *) {
  //
  // Initialize branches.
  //
  Info("ConnectInputData","ConnectInputData of task %s\n",GetName());

  fChain = (TChain*)GetInputData(0);
  fChain->SetBranchStatus("*FMD*",0);
  fChain->SetBranchStatus("*CaloClusters*",0);
  fESD = new AliESDEvent();
  fESD->ReadFromTree(fChain);
}

//___________________________________________________________________________
void AliCFSingleTrackTask::CreateOutputObjects() {
  //HERE ONE CAN CREATE OUTPUT OBJECTS, IN PARTICULAR IF THE OBJECT PARAMETERS DON'T NEED
  //TO BE SET BEFORE THE EXECUTION OF THE TASK
  //
  Info("CreateOutputObjects","CreateOutputObjects of task %s\n", GetName());

  //slot #0
  fHistEventsProcessed = new TH1I("fHistEventsProcessed","",1,0,1) ;

  //slot #2
  fQAHistList = new TList();
  fCFManager->InitQAHistos();
  fCFManager->AddQAHistosToList(fQAHistList);
}

#endif
Commit	Line	Data
563113d0	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, 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	//-----------------------------------------------------------------------
	17	// Example of task running on AliEn (CAF?)
	18	// which provides standard way of calculating acceptance and efficiency
	19	// between different steps of the procedure.
	20	// The ouptut of the task is a AliCFContainer from which the efficiencies
	21	// can be calculated
	22	//-----------------------------------------------------------------------
	23	// Author : R. Vernet, Consorzio Cometa - Catania (it)
	24	//-----------------------------------------------------------------------
	25
	26
	27	#ifndef ALICFSINGLETRACKTASK_CXX
	28	#define ALICFSINGLETRACKTASK_CXX
	29	#include <TROOT.h>
	30	#include <TInterpreter.h>
	31
	32	#include "AliCFSingleTrackTask.h"
	33	#include "TCanvas.h"
	34	#include "AliStack.h"
	35	#include "TParticle.h"
	36	#include "TH1I.h"
	37	#include "TChain.h"
	38	#include "AliMCEventHandler.h"
	39	#include "AliMCEvent.h"
	40	#include "AliAnalysisManager.h"
	41	#include "AliESDEvent.h"
	42	#include "AliCFManager.h"
	43	#include "AliCFCutBase.h"
	44	#include "AliCFContainer.h"
	45	#include "TChain.h"
	46	#include "AliESDtrack.h"
	47	#include "AliLog.h"
	48	ClassImp(AliCFSingleTrackTask)
	49	//__________________________________________________________________________
	50	AliCFSingleTrackTask::AliCFSingleTrackTask() :
	51	fChain(0x0),
	52	fESD(0x0),
	53	fCFManager(0x0),
	54	fQAHistList(0x0),
	55	fHistEventsProcessed(0x0)
	56	{
	57	//Defual ctor
	58	}
	59	//___________________________________________________________________________
	60	AliCFSingleTrackTask::AliCFSingleTrackTask(const Char_t* name) :
	61	AliAnalysisTask(name,"AliCFSingleTrackTask"),
	62	fChain(0x0),
	63	fESD(0x0),
	64	fCFManager(0x0),
65	fQAHistList(0x0),
66	fHistEventsProcessed(0x0)
67	{
68	//
69	// Constructor. Initialization of Inputs and Outputs
70	//
71	Info("AliCFSingleTrackTask","Calling Constructor");
72	DefineInput (0,TChain::Class());
73	DefineOutput(0,TH1I::Class());
74	DefineOutput(1,AliCFContainer::Class());
75	DefineOutput(2,TList::Class());
76	}
77
78	//___________________________________________________________________________
79	AliCFSingleTrackTask& AliCFSingleTrackTask::operator=(const AliCFSingleTrackTask& c)
80	{
81	//
82	// Assignment operator
83	//
84	if (this!=&c) {
85	AliAnalysisTask::operator=(c) ;
86	fChain = c.fChain;
87	fESD = c.fESD;
88	fCFManager = c.fCFManager;
89	fQAHistList = c.fQAHistList ;
90	fHistEventsProcessed = c.fHistEventsProcessed;
91	}
92	return *this;
93	}
94
95	//___________________________________________________________________________
96	AliCFSingleTrackTask::AliCFSingleTrackTask(const AliCFSingleTrackTask& c) :
97	AliAnalysisTask(c),
98	fChain(c.fChain),
99	fESD(c.fESD),
100	fCFManager(c.fCFManager),
101	fQAHistList(c.fQAHistList),
102	fHistEventsProcessed(c.fHistEventsProcessed)
103	{
104	//
105	// Copy Constructor
106	//
107	}
108
109	//___________________________________________________________________________
110	AliCFSingleTrackTask::~AliCFSingleTrackTask() {
111	//
112	//destructor
113	//
114	Info("~AliCFSingleTrackTask","Calling Destructor");
115	if (fChain) delete fChain ;
116	if (fESD) delete fESD ;
117	if (fCFManager) delete fCFManager ;
118	if (fHistEventsProcessed) delete fHistEventsProcessed ;
119	if (fQAHistList) {fQAHistList->Clear(); delete fQAHistList;}
120	}
121
122	//___________________________________________________________________________
123
124	void AliCFSingleTrackTask::Init()
125	{
126
127	}
128	//_________________________________________________
129	void AliCFSingleTrackTask::Exec(Option_t *)
130	{
131	//
132	// Main loop function
133	//
134	Info("Exec","") ;
135	// Get the mc truth
136	AliMCEventHandler* mcTruth = (AliMCEventHandler*)((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());
137
138	if (!mcTruth) Error("Exec","NO MC INFO FOUND... EXITING\n");
139
140	// transform possible old AliESD into AliESDEvent
141
142	if (fESD->GetAliESDOld()) fESD->CopyFromOldESD(); //transition to new ESD format
143
144	//pass the MC evt handler to the cuts that need it
145
146	fCFManager->SetEventInfo(mcTruth);
147
148	// Get the MC event
149	AliMCEvent* mcEvent = mcTruth->MCEvent();
150
151	// MC-event selection
152	Float_t containerInput[2] ;
153
154	//loop on the MC event
155	for (Int_t ipart=0; ipart<mcEvent->GetNumberOfTracks(); ipart++) {
156	AliMCParticle *mcPart = mcEvent->GetTrack(ipart);
157
158	//check the MC-level cuts
159	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;
160
161	containerInput[0] = (Float_t)mcPart->Pt();
162	containerInput[1] = mcPart->Eta() ;
163	//fill the container for Gen-level selection
164	fCFManager->GetParticleContainer()->Fill(containerInput,kStepGenerated);
165
166	//check the Acceptance-level cuts
167	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcPart)) continue;
168	//fill the container for Acceptance-level selection
169	fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructible);
170	}
171
172	//Now go to rec level
173	for (Int_t iTrack = 0; iTrack<fESD->GetNumberOfTracks(); iTrack++) {
174
175	AliESDtrack* track = fESD->GetTrack(iTrack);
176
177	fCFManager->FillQABeforeParticleCuts(AliCFManager::kPartRecCuts,track);
178	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,track)) continue;
179	fCFManager->FillQAAfterParticleCuts(AliCFManager::kPartRecCuts,track);
180
181	// is track associated to particle ?
182	if (track->GetLabel()<0) continue;
183	AliMCParticle *mcPart = mcEvent->GetTrack(track->GetLabel());
184
185	// check if this track was part of the signal
186	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;
187
188	//fill the container
189	Double_t mom[3];
190	track->GetPxPyPz(mom);
191	Double_t pt=TMath::Sqrt(mom[0]mom[0]+mom[1]mom[1]);
192	containerInput[0] = pt ;
193	containerInput[1] = track->Eta();
194	fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructed) ;
195	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,track)) continue ;
196	fCFManager->GetParticleContainer()->Fill(containerInput,kStepSelected);
197	}
198
199	fHistEventsProcessed->Fill(0);
200	PostData(0,fHistEventsProcessed) ;
201	PostData(1,fCFManager->GetParticleContainer()) ;
202	PostData(2,fQAHistList) ;
203	}
204
205
206	//___________________________________________________________________________
207	void AliCFSingleTrackTask::Terminate(Option_t*)
208	{
209	// The Terminate() function is the last function to be called during
210	// a query. It always runs on the client, it can be used to present
211	// the results graphically or save the results to file.
212
213	Info("Terminate","");
214	AliAnalysisTask::Terminate();
215
216
217	Double_t max1 = fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetMaximum();
218	Double_t max2 = fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetMaximum();
219
220	fCFManager->GetParticleContainer()->ShowProjection(0,0)->GetYaxis()->SetRangeUser(0,max1*1.2);
221	fCFManager->GetParticleContainer()->ShowProjection(0,1)->GetYaxis()->SetRangeUser(0,max1*1.2);
222	fCFManager->GetParticleContainer()->ShowProjection(0,2)->GetYaxis()->SetRangeUser(0,max1*1.2);
223	fCFManager->GetParticleContainer()->ShowProjection(0,3)->GetYaxis()->SetRangeUser(0,max1*1.2);
224
225	fCFManager->GetParticleContainer()->ShowProjection(1,0)->GetYaxis()->SetRangeUser(0,max2*1.2);
226	fCFManager->GetParticleContainer()->ShowProjection(1,1)->GetYaxis()->SetRangeUser(0,max2*1.2);
227	fCFManager->GetParticleContainer()->ShowProjection(1,2)->GetYaxis()->SetRangeUser(0,max2*1.2);
228	fCFManager->GetParticleContainer()->ShowProjection(1,3)->GetYaxis()->SetRangeUser(0,max2*1.2);
229
230	fCFManager->GetParticleContainer()->ShowProjection(0,0)->SetMarkerStyle(23) ;
231	fCFManager->GetParticleContainer()->ShowProjection(0,1)->SetMarkerStyle(24) ;
232	fCFManager->GetParticleContainer()->ShowProjection(0,2)->SetMarkerStyle(25) ;
233	fCFManager->GetParticleContainer()->ShowProjection(0,3)->SetMarkerStyle(26) ;
234
235	fCFManager->GetParticleContainer()->ShowProjection(1,0)->SetMarkerStyle(23) ;
236	fCFManager->GetParticleContainer()->ShowProjection(1,1)->SetMarkerStyle(24) ;
237	fCFManager->GetParticleContainer()->ShowProjection(1,2)->SetMarkerStyle(25) ;
238	fCFManager->GetParticleContainer()->ShowProjection(1,3)->SetMarkerStyle(26) ;
239
240	TCanvas * c =new TCanvas("c","",1400,800);
241	c->Divide(4,2);
242
243	// TCanvas * c1 =new TCanvas("c1","",600,400);
244	c->cd(1);
245	fCFManager->GetParticleContainer()->ShowProjection(0,0)->Draw("p");
246	c->cd(2);
247	fCFManager->GetParticleContainer()->ShowProjection(0,1)->Draw("p");
248	c->cd(3);
249	fCFManager->GetParticleContainer()->ShowProjection(0,2)->Draw("p");
250	c->cd(4);
251	fCFManager->GetParticleContainer()->ShowProjection(0,3)->Draw("p");
252
253	// TCanvas * c2 =new TCanvas("c2","",600,400);
254	c->cd(5);
255	fCFManager->GetParticleContainer()->ShowProjection(1,0)->Draw("p");
256	c->cd(6);
257	fCFManager->GetParticleContainer()->ShowProjection(1,1)->Draw("p");
258	c->cd(7);
259	fCFManager->GetParticleContainer()->ShowProjection(1,2)->Draw("p");
260	c->cd(8);
261	fCFManager->GetParticleContainer()->ShowProjection(1,3)->Draw("p");
262
263	c->SaveAs("plots.eps");
264
265	delete fHistEventsProcessed ;
266	}
267
268	//___________________________________________________________________________
269	void AliCFSingleTrackTask::ConnectInputData(Option_t *) {
270	//
271	// Initialize branches.
272	//
273	Info("ConnectInputData","ConnectInputData of task %s\n",GetName());
274
275	fChain = (TChain*)GetInputData(0);
276	fChain->SetBranchStatus("FMD",0);
277	fChain->SetBranchStatus("CaloClusters",0);
278	fESD = new AliESDEvent();
279	fESD->ReadFromTree(fChain);
280	}
281
282	//___________________________________________________________________________
283	void AliCFSingleTrackTask::CreateOutputObjects() {
284	//HERE ONE CAN CREATE OUTPUT OBJECTS, IN PARTICULAR IF THE OBJECT PARAMETERS DON'T NEED
285	//TO BE SET BEFORE THE EXECUTION OF THE TASK
286	//
287	Info("CreateOutputObjects","CreateOutputObjects of task %s\n", GetName());
288
289	//slot #0
290	fHistEventsProcessed = new TH1I("fHistEventsProcessed","",1,0,1) ;
291
292	//slot #2
293	fQAHistList = new TList();
294	fCFManager->InitQAHistos();
295	fCFManager->AddQAHistosToList(fQAHistList);
296	}
297
298	#endif