[u/mrichter/AliRoot.git] / CORRFW / test / AliCFV0Task.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 ALICFV0TASK_CXX
#define ALICFV0TASK_CXX

#include "AliCFV0Task.h"
#include "TCanvas.h"
#include "AliStack.h"
#include "TParticle.h"
#include "TH1I.h"
#include "AliMCEvent.h"
#include "AliCFManager.h"
#include "AliCFContainer.h"
#include "AliESDtrack.h"
#include "AliLog.h"
#include "AliESDv0.h"
#include "AliV0vertexer.h"
#include "AliCFPair.h"
#include "AliESDEvent.h"
#include "TChain.h"
#include "AliCFParticleGenCuts.h"

//__________________________________________________________________________
AliCFV0Task::AliCFV0Task() :
  AliAnalysisTaskSE(),
  fRebuildV0s(0),
  fV0PDG(310),
  fCFManager(0x0),
  fHistEventsProcessed(0x0)
{
  //
  //Default ctor
  //
}
//___________________________________________________________________________
AliCFV0Task::AliCFV0Task(const Char_t* name) :
  AliAnalysisTaskSE(name),
  fRebuildV0s(0),
  fV0PDG(310),
  fCFManager(0x0),
  fHistEventsProcessed(0x0)
{
  //
  // Constructor. Initialization of Inputs and Outputs
  //
  Info("AliCFV0Task","Calling Constructor");
  /*
    DefineInput(0) and DefineOutput(0)
    are taken care of by AliAnalysisTaskSE constructor
  */
  DefineOutput(1,TH1I::Class());
  DefineOutput(2,AliCFContainer::Class());
//   DefineOutput(3,TList::Class());
}

//___________________________________________________________________________
AliCFV0Task& AliCFV0Task::operator=(const AliCFV0Task& c) 
{
  //
  // Assignment operator
  //
  if (this!=&c) {
    AliAnalysisTaskSE::operator=(c) ;
    fRebuildV0s = c.fRebuildV0s;
    fV0PDG      = c.fV0PDG;
    fCFManager  = c.fCFManager;
    fHistEventsProcessed = c.fHistEventsProcessed;
  }
  return *this;
}

//___________________________________________________________________________
AliCFV0Task::AliCFV0Task(const AliCFV0Task& c) :
  AliAnalysisTaskSE(c),
  fRebuildV0s(c.fRebuildV0s),
  fV0PDG(c.fV0PDG),
  fCFManager(c.fCFManager),
  fHistEventsProcessed(c.fHistEventsProcessed)
{
  //
  // Copy Constructor
  //
}

//___________________________________________________________________________
AliCFV0Task::~AliCFV0Task() {
  //
  //destructor
  //
  Info("~AliCFV0Task","Calling Destructor");
  if (fCFManager)           delete fCFManager ;
  if (fHistEventsProcessed) delete fHistEventsProcessed ;
}

//_________________________________________________
void AliCFV0Task::UserExec(Option_t *)
{
  //
  // Main loop function
  //
  Info("UserExec","") ;

  AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
  if (!fESD) {
    Error("UserExec","NO ESD FOUND!");
    return;
  }

  if (!fMCEvent) Error("UserExec","NO MC INFO FOUND!");
  fCFManager->SetEventInfo(fMCEvent);

  // MC-event selection
  Double_t containerInput[2] ;
        
  //loop on the MC event
  Info("UserExec","Looping on MC event");
  for (Int_t ipart=0; ipart<fMCEvent->GetNumberOfTracks(); ipart++) { 
    AliMCParticle *mcPart  = fMCEvent->GetTrack(ipart);

    //check the MC-level cuts
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;
    containerInput[0] = mcPart->Pt();
    containerInput[1] = mcPart->Y() ;
    //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
  Info("UserExec","Looping on ESD event");

  if (fRebuildV0s) RebuildV0s(fESD) ;
  Info("UserExec","There are %d V0s in event",fESD->GetNumberOfV0s());
  for (Int_t iV0 = 0; iV0<fESD->GetNumberOfV0s(); iV0++) {

    AliESDv0* esdV0 = fESD->GetV0(iV0);

    //check if mother reconstructed V0 can be associated to a MC V0
    Int_t labMCV0 = IsMcV0(esdV0) ;
    if (labMCV0 <0) continue;

    esdV0->ChangeMassHypothesis(fV0PDG); //important to do that before entering the cut check

    AliCFPair pair(esdV0,fESD);
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,&pair)) continue;

    //check if associated MC v0 passes the cuts
    AliMCParticle* mcV0 = fMCEvent->GetTrack(labMCV0);
    if (!mcV0) continue;

    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcV0)) continue; 
    
    //fill the container
    Double_t mom[3];
    esdV0->GetPxPyPz(mom[0],mom[1],mom[2]);
    Double_t pt2 = mom[0]*mom[0]+mom[1]*mom[1] ;
    Double_t pt  = TMath::Sqrt(pt2);
    Double_t energy  = TMath::Sqrt(pt2 + mom[2]*mom[2] + TMath::Power(TDatabasePDG::Instance()->GetParticle(fV0PDG)->Mass(),2));

    containerInput[0] = pt ;
    containerInput[1] = GetRapidity(energy,mom[2]);
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructed) ;   
    if (!fCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,&pair)) continue ;
    fCFManager->GetParticleContainer()->Fill(containerInput,kStepSelected);
  }
  
  fHistEventsProcessed->Fill(0);
  /* PostData(0) is taken care of by AliAnalysisTaskSE */
  PostData(1,fHistEventsProcessed) ;
  PostData(2,fCFManager->GetParticleContainer()) ;
}


//___________________________________________________________________________
void AliCFV0Task::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","");
  AliAnalysisTaskSE::Terminate();


  //draw some example plots....

  AliCFContainer *cont= dynamic_cast<AliCFContainer*> (GetOutputData(2));

  TH1D* h00 =   cont->ShowProjection(0,0) ;
  TH1D* h01 =   cont->ShowProjection(0,1) ;
  TH1D* h02 =   cont->ShowProjection(0,2) ;
  TH1D* h03 =   cont->ShowProjection(0,3) ;

  TH1D* h10 =   cont->ShowProjection(1,0) ;
  TH1D* h11 =   cont->ShowProjection(1,1) ;
  TH1D* h12 =   cont->ShowProjection(1,2) ;
  TH1D* h13 =   cont->ShowProjection(1,3) ;

  Double_t max1 = h00->GetMaximum();
  Double_t max2 = h10->GetMaximum();

  h00->GetYaxis()->SetRangeUser(0,max1*1.2);
  h01->GetYaxis()->SetRangeUser(0,max1*1.2);
  h02->GetYaxis()->SetRangeUser(0,max1*1.2);
  h03->GetYaxis()->SetRangeUser(0,max1*1.2);

  h10->GetYaxis()->SetRangeUser(0,max2*1.2);
  h11->GetYaxis()->SetRangeUser(0,max2*1.2);
  h12->GetYaxis()->SetRangeUser(0,max2*1.2);
  h13->GetYaxis()->SetRangeUser(0,max2*1.2);

  h00->SetMarkerStyle(23) ;
  h01->SetMarkerStyle(24) ;
  h02->SetMarkerStyle(25) ;
  h03->SetMarkerStyle(26) ;

  h10->SetMarkerStyle(23) ;
  h11->SetMarkerStyle(24) ;
  h12->SetMarkerStyle(25) ;
  h13->SetMarkerStyle(26) ;

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

  c->cd(1);
  h00->Draw("p");
  c->cd(2);
  h01->Draw("p");
  c->cd(3);
  h02->Draw("p");
  c->cd(4);
  h03->Draw("p");
  c->cd(5);
  h10->Draw("p");
  c->cd(6);
  h11->Draw("p");
  c->cd(7);
  h12->Draw("p");
  c->cd(8);
  h13->Draw("p");

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

//___________________________________________________________________________
void AliCFV0Task::UserCreateOutputObjects() {
  //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("UserCreateOutputObjects","CreateOutputObjects of task %s\n", GetName());

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

//___________________________________________________________________________
Int_t AliCFV0Task::GetV0Label(UInt_t lab1, UInt_t lab2) const {
  //
  // returns the label of the V0, given the labels of the 2 daughter tracks
  // returns -1 if the V0 is fake
  //
  
  AliStack* stack = fMCEvent->Stack();
  TParticle* part1 = stack->Particle(lab1) ;
  TParticle* part2 = stack->Particle(lab2) ;
  
  Int_t part1MotherLab=part1->GetFirstMother();
  Int_t part2MotherLab=part2->GetFirstMother();

  if (part1MotherLab==-1 || part2MotherLab==-1) return -1 ;
  if (part1MotherLab != part2MotherLab )        return -1 ;
  
  if (stack->Particle(part1MotherLab)->GetPdgCode() != fV0PDG ) return -1 ;

  switch (fV0PDG) {
  case kK0Short : 
    if ( (part1->GetPdgCode()==  -211 && part2->GetPdgCode()==  211)  || 
	 (part1->GetPdgCode()==   211 && part2->GetPdgCode()== -211)   )   return part1MotherLab ;
    break ;
  case kLambda0 :
    if ( (part1->GetPdgCode()==  -211 && part2->GetPdgCode()== 2212)  || 
	 (part1->GetPdgCode()==  2212 && part2->GetPdgCode()== -211)   )   return part1MotherLab ;
    break ;
  case kLambda0Bar :
    if ( (part1->GetPdgCode()==   211 && part2->GetPdgCode()== -2212) || 
	 (part1->GetPdgCode()== -2212 && part2->GetPdgCode()==   211)  )   return part1MotherLab ;
    break ;
  default :
    return -1;
    break ;
  }
  
  return -1 ;
}

//___________________________________________________________________________
Double_t AliCFV0Task::GetRapidity(Double_t energy, Double_t pz) {
  if (energy == pz || energy == -pz) {
    printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
    return 999;
  }
  if (energy < pz) {
    printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
    return 999;
  }
  Double_t y = 0.5 * log((energy + pz) / (energy - pz));
  return y;
} 

//___________________________________________________________________________
Int_t AliCFV0Task::IsMcV0(AliESDv0* v0) const {

  AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(fInputEvent);

  Int_t nindex = v0->GetNindex();
  Int_t pindex = v0->GetPindex();
  AliESDtrack *nTrack = fESD->GetTrack(nindex) ;
  AliESDtrack *pTrack = fESD->GetTrack(pindex) ;
  
  if (!nTrack || !pTrack) return -1 ;

  Int_t nlab  = nTrack->GetLabel() ;
  Int_t plab  = pTrack->GetLabel() ;
  
  if (nlab <0 || plab <0) return -1 ;

  return GetV0Label((UInt_t)nlab,(UInt_t)plab) ;
}


//___________________________________________________________________________
void AliCFV0Task::RebuildV0s(AliESDEvent* fESD) {
  
  fESD->ResetV0s();

  //These are pp cuts : to change if Pb+Pb !
  Double_t cuts[]={33,  // max. allowed chi2
		   0.01,// min. allowed negative daughter's impact parameter 
		   0.01,// min. allowed positive daughter's impact parameter 
		   0.5,// max. allowed DCA between the daughter tracks
		   0.98,// max. allowed cosine of V0's pointing angle
		   0.2,  // min. radius of the fiducial volume
		   100.   // max. radius of the fiducial volume
  };
  //   AliV0vertexer* v0Vertexer = new AliV0vertexer(cuts);
  //   v0Vertexer->SetVertex(primVertexPos);
  AliV0vertexer* v0Vertexer = new AliV0vertexer();
  v0Vertexer->SetCuts(cuts) ;
  v0Vertexer->Tracks2V0vertices(fESD);
  delete v0Vertexer ;
}

#endif
Commit	Line	Data
2fbc0b17	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 ALICFV0TASK_CXX
	28	#define ALICFV0TASK_CXX
2fbc0b17	29
	30	#include "AliCFV0Task.h"
	31	#include "TCanvas.h"
	32	#include "AliStack.h"
	33	#include "TParticle.h"
	34	#include "TH1I.h"
2fbc0b17	35	#include "AliMCEvent.h"
2fbc0b17	36	#include "AliCFManager.h"
2fbc0b17	37	#include "AliCFContainer.h"
2fbc0b17	38	#include "AliESDtrack.h"
	39	#include "AliLog.h"
	40	#include "AliESDv0.h"
	41	#include "AliV0vertexer.h"
	42	#include "AliCFPair.h"
318a0e1f	43	#include "AliESDEvent.h"
	44	#include "TChain.h"
	45	#include "AliCFParticleGenCuts.h"
2fbc0b17	46
	47	//__________________________________________________________________________
	48	AliCFV0Task::AliCFV0Task() :
318a0e1f	49	AliAnalysisTaskSE(),
2fbc0b17	50	fRebuildV0s(0),
2fbc0b17	51	fV0PDG(310),
2fbc0b17	52	fCFManager(0x0),
	53	fHistEventsProcessed(0x0)
	54	{
318a0e1f	55	//
	56	//Default ctor
	57	//
2fbc0b17	58	}
	59	//___________________________________________________________________________
	60	AliCFV0Task::AliCFV0Task(const Char_t* name) :
318a0e1f	61	AliAnalysisTaskSE(name),
2fbc0b17	62	fRebuildV0s(0),
2fbc0b17	63	fV0PDG(310),
2fbc0b17	64	fCFManager(0x0),
	65	fHistEventsProcessed(0x0)
	66	{
	67	//
	68	// Constructor. Initialization of Inputs and Outputs
	69	//
	70	Info("AliCFV0Task","Calling Constructor");
318a0e1f	71	/*
	72	DefineInput(0) and DefineOutput(0)
	73	are taken care of by AliAnalysisTaskSE constructor
	74	*/
	75	DefineOutput(1,TH1I::Class());
	76	DefineOutput(2,AliCFContainer::Class());
	77	// DefineOutput(3,TList::Class());
2fbc0b17	78	}
	79
	80	//___________________________________________________________________________
	81	AliCFV0Task& AliCFV0Task::operator=(const AliCFV0Task& c)
	82	{
	83	//
	84	// Assignment operator
	85	//
	86	if (this!=&c) {
318a0e1f	87	AliAnalysisTaskSE::operator=(c) ;
2fbc0b17	88	fRebuildV0s = c.fRebuildV0s;
2fbc0b17	89	fV0PDG = c.fV0PDG;
2fbc0b17	90	fCFManager = c.fCFManager;
	91	fHistEventsProcessed = c.fHistEventsProcessed;
	92	}
	93	return *this;
	94	}
	95
	96	//___________________________________________________________________________
	97	AliCFV0Task::AliCFV0Task(const AliCFV0Task& c) :
318a0e1f	98	AliAnalysisTaskSE(c),
2fbc0b17	99	fRebuildV0s(c.fRebuildV0s),
2fbc0b17	100	fV0PDG(c.fV0PDG),
2fbc0b17	101	fCFManager(c.fCFManager),
	102	fHistEventsProcessed(c.fHistEventsProcessed)
	103	{
	104	//
	105	// Copy Constructor
	106	//
	107	}
	108
	109	//___________________________________________________________________________
	110	AliCFV0Task::~AliCFV0Task() {
	111	//
	112	//destructor
	113	//
	114	Info("~AliCFV0Task","Calling Destructor");
2fbc0b17	115	if (fCFManager) delete fCFManager ;
	116	if (fHistEventsProcessed) delete fHistEventsProcessed ;
	117	}
	118
2fbc0b17	119	//_________________________________________________
318a0e1f	120	void AliCFV0Task::UserExec(Option_t *)
2fbc0b17	121	{
	122	//
	123	// Main loop function
	124	//
318a0e1f	125	Info("UserExec","") ;
2fbc0b17	126
318a0e1f	127	AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
	128	if (!fESD) {
	129	Error("UserExec","NO ESD FOUND!");
	130	return;
	131	}
2fbc0b17	132
318a0e1f	133	if (!fMCEvent) Error("UserExec","NO MC INFO FOUND!");
318a0e1f	134	fCFManager->SetEventInfo(fMCEvent);
2fbc0b17	135
	136	// MC-event selection
	137	Double_t containerInput[2] ;
	138
	139	//loop on the MC event
318a0e1f	140	Info("UserExec","Looping on MC event");
	141	for (Int_t ipart=0; ipart<fMCEvent->GetNumberOfTracks(); ipart++) {
	142	AliMCParticle *mcPart = fMCEvent->GetTrack(ipart);
2fbc0b17	143
	144	//check the MC-level cuts
	145	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcPart)) continue;
	146	containerInput[0] = mcPart->Pt();
1d519a00	147	containerInput[1] = mcPart->Y() ;
2fbc0b17	148	//fill the container for Gen-level selection
	149	fCFManager->GetParticleContainer()->Fill(containerInput,kStepGenerated);
	150
	151	//check the Acceptance-level cuts
	152	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartAccCuts,mcPart)) continue;
	153	//fill the container for Acceptance-level selection
	154	fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructible);
	155	}
	156
	157
	158	//Now go to rec level
318a0e1f	159	Info("UserExec","Looping on ESD event");
2fbc0b17	160
318a0e1f	161	if (fRebuildV0s) RebuildV0s(fESD) ;
318a0e1f	162	Info("UserExec","There are %d V0s in event",fESD->GetNumberOfV0s());
2fbc0b17	163	for (Int_t iV0 = 0; iV0<fESD->GetNumberOfV0s(); iV0++) {
	164
	165	AliESDv0* esdV0 = fESD->GetV0(iV0);
	166
	167	//check if mother reconstructed V0 can be associated to a MC V0
318a0e1f	168	Int_t labMCV0 = IsMcV0(esdV0) ;
2fbc0b17	169	if (labMCV0 <0) continue;
	170
	171	esdV0->ChangeMassHypothesis(fV0PDG); //important to do that before entering the cut check
	172
	173	AliCFPair pair(esdV0,fESD);
	174	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartRecCuts,&pair)) continue;
	175
	176	//check if associated MC v0 passes the cuts
318a0e1f	177	AliMCParticle* mcV0 = fMCEvent->GetTrack(labMCV0);
2fbc0b17	178	if (!mcV0) continue;
	179
	180	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartGenCuts,mcV0)) continue;
	181
	182	//fill the container
	183	Double_t mom[3];
	184	esdV0->GetPxPyPz(mom[0],mom[1],mom[2]);
	185	Double_t pt2 = mom[0]mom[0]+mom[1]mom[1] ;
	186	Double_t pt = TMath::Sqrt(pt2);
	187	Double_t energy = TMath::Sqrt(pt2 + mom[2]*mom[2] + TMath::Power(TDatabasePDG::Instance()->GetParticle(fV0PDG)->Mass(),2));
	188
	189	containerInput[0] = pt ;
	190	containerInput[1] = GetRapidity(energy,mom[2]);
	191	fCFManager->GetParticleContainer()->Fill(containerInput,kStepReconstructed) ;
	192	if (!fCFManager->CheckParticleCuts(AliCFManager::kPartSelCuts,&pair)) continue ;
	193	fCFManager->GetParticleContainer()->Fill(containerInput,kStepSelected);
	194	}
	195
	196	fHistEventsProcessed->Fill(0);
318a0e1f	197	/* PostData(0) is taken care of by AliAnalysisTaskSE */
	198	PostData(1,fHistEventsProcessed) ;
	199	PostData(2,fCFManager->GetParticleContainer()) ;
2fbc0b17	200	}
	201
	202
	203	//___________________________________________________________________________
	204	void AliCFV0Task::Terminate(Option_t*)
	205	{
	206	// The Terminate() function is the last function to be called during
	207	// a query. It always runs on the client, it can be used to present
	208	// the results graphically or save the results to file.
	209
	210	Info("Terminate","");
318a0e1f	211	AliAnalysisTaskSE::Terminate();
	212
	213
	214	//draw some example plots....
	215
	216	AliCFContainer cont= dynamic_cast<AliCFContainer> (GetOutputData(2));
	217
	218	TH1D* h00 = cont->ShowProjection(0,0) ;
	219	TH1D* h01 = cont->ShowProjection(0,1) ;
	220	TH1D* h02 = cont->ShowProjection(0,2) ;
	221	TH1D* h03 = cont->ShowProjection(0,3) ;
2fbc0b17	222
318a0e1f	223	TH1D* h10 = cont->ShowProjection(1,0) ;
	224	TH1D* h11 = cont->ShowProjection(1,1) ;
	225	TH1D* h12 = cont->ShowProjection(1,2) ;
	226	TH1D* h13 = cont->ShowProjection(1,3) ;
2fbc0b17	227
318a0e1f	228	Double_t max1 = h00->GetMaximum();
318a0e1f	229	Double_t max2 = h10->GetMaximum();
2fbc0b17	230
318a0e1f	231	h00->GetYaxis()->SetRangeUser(0,max1*1.2);
	232	h01->GetYaxis()->SetRangeUser(0,max1*1.2);
	233	h02->GetYaxis()->SetRangeUser(0,max1*1.2);
	234	h03->GetYaxis()->SetRangeUser(0,max1*1.2);
2fbc0b17	235
318a0e1f	236	h10->GetYaxis()->SetRangeUser(0,max2*1.2);
	237	h11->GetYaxis()->SetRangeUser(0,max2*1.2);
	238	h12->GetYaxis()->SetRangeUser(0,max2*1.2);
	239	h13->GetYaxis()->SetRangeUser(0,max2*1.2);
2fbc0b17	240
318a0e1f	241	h00->SetMarkerStyle(23) ;
	242	h01->SetMarkerStyle(24) ;
	243	h02->SetMarkerStyle(25) ;
	244	h03->SetMarkerStyle(26) ;
2fbc0b17	245
318a0e1f	246	h10->SetMarkerStyle(23) ;
	247	h11->SetMarkerStyle(24) ;
	248	h12->SetMarkerStyle(25) ;
	249	h13->SetMarkerStyle(26) ;
2fbc0b17	250
	251	TCanvas * c =new TCanvas("c","",1400,800);
	252	c->Divide(4,2);
	253
	254	c->cd(1);
318a0e1f	255	h00->Draw("p");
2fbc0b17	256	c->cd(2);
318a0e1f	257	h01->Draw("p");
2fbc0b17	258	c->cd(3);
318a0e1f	259	h02->Draw("p");
2fbc0b17	260	c->cd(4);
318a0e1f	261	h03->Draw("p");
2fbc0b17	262	c->cd(5);
318a0e1f	263	h10->Draw("p");
2fbc0b17	264	c->cd(6);
318a0e1f	265	h11->Draw("p");
2fbc0b17	266	c->cd(7);
318a0e1f	267	h12->Draw("p");
2fbc0b17	268	c->cd(8);
318a0e1f	269	h13->Draw("p");
2fbc0b17	270
2fbc0b17	271	c->SaveAs("plots.eps");
2fbc0b17	272	}
	273
	274	//___________________________________________________________________________
318a0e1f	275	void AliCFV0Task::UserCreateOutputObjects() {
2fbc0b17	276	//HERE ONE CAN CREATE OUTPUT OBJECTS, IN PARTICULAR IF THE OBJECT PARAMETERS DON'T NEED
	277	//TO BE SET BEFORE THE EXECUTION OF THE TASK
	278	//
318a0e1f	279	Info("UserCreateOutputObjects","CreateOutputObjects of task %s\n", GetName());
2fbc0b17	280
318a0e1f	281	//slot #1
318a0e1f	282	OpenFile(1);
2fbc0b17	283	fHistEventsProcessed = new TH1I("fHistEventsProcessed","",1,0,1) ;
	284	}
	285
	286	//___________________________________________________________________________
318a0e1f	287	Int_t AliCFV0Task::GetV0Label(UInt_t lab1, UInt_t lab2) const {
2fbc0b17	288	//
	289	// returns the label of the V0, given the labels of the 2 daughter tracks
	290	// returns -1 if the V0 is fake
	291	//
	292
318a0e1f	293	AliStack* stack = fMCEvent->Stack();
2fbc0b17	294	TParticle* part1 = stack->Particle(lab1) ;
	295	TParticle* part2 = stack->Particle(lab2) ;
	296
	297	Int_t part1MotherLab=part1->GetFirstMother();
	298	Int_t part2MotherLab=part2->GetFirstMother();
318a0e1f	299
2fbc0b17	300	if (part1MotherLab==-1 \|\| part2MotherLab==-1) return -1 ;
2fbc0b17	301	if (part1MotherLab != part2MotherLab ) return -1 ;
318a0e1f	302
2fbc0b17	303	if (stack->Particle(part1MotherLab)->GetPdgCode() != fV0PDG ) return -1 ;
	304
	305	switch (fV0PDG) {
	306	case kK0Short :
	307	if ( (part1->GetPdgCode()== -211 && part2->GetPdgCode()== 211) \|\|
	308	(part1->GetPdgCode()== 211 && part2->GetPdgCode()== -211) ) return part1MotherLab ;
	309	break ;
	310	case kLambda0 :
	311	if ( (part1->GetPdgCode()== -211 && part2->GetPdgCode()== 2212) \|\|
	312	(part1->GetPdgCode()== 2212 && part2->GetPdgCode()== -211) ) return part1MotherLab ;
	313	break ;
	314	case kLambda0Bar :
	315	if ( (part1->GetPdgCode()== 211 && part2->GetPdgCode()== -2212) \|\|
	316	(part1->GetPdgCode()== -2212 && part2->GetPdgCode()== 211) ) return part1MotherLab ;
	317	break ;
	318	default :
	319	return -1;
	320	break ;
	321	}
	322
	323	return -1 ;
	324	}
	325
	326	//___________________________________________________________________________
	327	Double_t AliCFV0Task::GetRapidity(Double_t energy, Double_t pz) {
	328	if (energy == pz \|\| energy == -pz) {
	329	printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
	330	return 999;
	331	}
	332	if (energy < pz) {
	333	printf("GetRapidity : ERROR : rapidity for 4-vector with E = Pz -- infinite result");
	334	return 999;
	335	}
	336	Double_t y = 0.5 * log((energy + pz) / (energy - pz));
	337	return y;
	338	}
	339
	340	//___________________________________________________________________________
318a0e1f	341	Int_t AliCFV0Task::IsMcV0(AliESDv0* v0) const {
	342
	343	AliESDEvent* fESD = dynamic_cast<AliESDEvent*>(fInputEvent);
	344
2fbc0b17	345	Int_t nindex = v0->GetNindex();
2fbc0b17	346	Int_t pindex = v0->GetPindex();
318a0e1f	347	AliESDtrack *nTrack = fESD->GetTrack(nindex) ;
318a0e1f	348	AliESDtrack *pTrack = fESD->GetTrack(pindex) ;
2fbc0b17	349
	350	if (!nTrack \|\| !pTrack) return -1 ;
	351
	352	Int_t nlab = nTrack->GetLabel() ;
	353	Int_t plab = pTrack->GetLabel() ;
	354
	355	if (nlab <0 \|\| plab <0) return -1 ;
	356
318a0e1f	357	return GetV0Label((UInt_t)nlab,(UInt_t)plab) ;
2fbc0b17	358	}
	359
	360
	361	//___________________________________________________________________________
318a0e1f	362	void AliCFV0Task::RebuildV0s(AliESDEvent* fESD) {
2fbc0b17	363
	364	fESD->ResetV0s();
	365
	366	//These are pp cuts : to change if Pb+Pb !
	367	Double_t cuts[]={33, // max. allowed chi2
318a0e1f	368	0.01,// min. allowed negative daughter's impact parameter
	369	0.01,// min. allowed positive daughter's impact parameter
	370	0.5,// max. allowed DCA between the daughter tracks
	371	0.98,// max. allowed cosine of V0's pointing angle
	372	0.2, // min. radius of the fiducial volume
2fbc0b17	373	100. // max. radius of the fiducial volume
	374	};
	375	// AliV0vertexer* v0Vertexer = new AliV0vertexer(cuts);
	376	// v0Vertexer->SetVertex(primVertexPos);
	377	AliV0vertexer* v0Vertexer = new AliV0vertexer();
	378	v0Vertexer->SetCuts(cuts) ;
	379	v0Vertexer->Tracks2V0vertices(fESD);
	380	delete v0Vertexer ;
	381	}
	382
	383	#endif