ROOT logo
/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *								          *
 * Authors: Svein Lindal, Daniel Lohner	                     		  *
 * Version 1.0								  *
 *	                                                		  *
 *                                                                        *
 * based on: on older version (see aliroot up to v5-04-42-AN)             *
 *           AliV0Reader.cxx                                              *
 *           Authors: Kathrin Koch, Kenneth Aamodt, Ana Marin             *
 *                                                                        *
 * 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.		  *
 **************************************************************************/

////////////////////////////////////////////////
//---------------------------------------------
// Class reconstructing conversion photons from V0s
//---------------------------------------------
////////////////////////////////////////////////

// The AliAODConversionPhotons will return the Position (== ESDTrack->GetID())of the positive (negative) ESDTrack 
// in the Array of ESDTracks stored in the ESDEvent via GetTrackLabelPositive() (GetTrackLabelNagative()).
// Since it is the Position in the Array it is always positive.
// After the conversion ESD --> AOD each AOD track will give you the former Position in the ESDArray via the
// Function AODTrack->GetID(). AODTracks are stored for different TrackParameter (e.g. HybridTracks, TPC only ...). No Standard 
// AODTracks (not copies of AliExternalTrackParam) will be stored with negative values of AODTrack->GetID() (Formula: (ESDTrack->GetID()+1)*-1)
// This leads to the possibility of more than one AOD track with the same negative ID. For that reason all AOD tracks are additionally flaged.
// In this analysis we should therefore only use AODTracks with positive values of AODTrack->GetID().

// If you want to find the AODTrack corresponding to the daugher track of a AliAODConversionPhoton you have to find the AODTrack with
// AODTrack->GetID() == GetTrackLabelPositive() (GetTrackLabelNagative()).

#include <TGeoGlobalMagField.h>

#include "AliV0ReaderV1.h"
#include "AliKFParticle.h"
#include "AliAODv0.h"
#include "AliESDv0.h"
#include "AliAODEvent.h"
#include "AliESDEvent.h"
#include "AliPID.h"
#include "AliMCEvent.h"
#include "AliStack.h"
#include "AliMCEventHandler.h"
#include "AliESDpid.h"
#include "AliESDtrackCuts.h"
#include "TRandom3.h"
#include "AliGenCocktailEventHeader.h"
#include "TList.h"
#include "AliKFConversionPhoton.h"
#include "AliAODConversionPhoton.h"
#include "AliConversionPhotonBase.h"
#include "TVector.h"
#include "AliKFVertex.h"
#include "AliAODTrack.h"
#include "AliESDtrack.h"
#include "AliAnalysisManager.h"
#include "AliInputEventHandler.h"
#include "AliAODHandler.h"
#include "AliPIDResponse.h"
#include "TChain.h"
#include "TFile.h"
#include "TString.h"
#include "TObjArray.h"

class iostream;


using namespace std;

ClassImp(AliV0ReaderV1)

//________________________________________________________________________
AliV0ReaderV1::AliV0ReaderV1(const char *name) : AliAnalysisTaskSE(name),
	fConversionCuts(NULL),
	fEventCuts(NULL),
	fConversionGammas(NULL),
	fUseImprovedVertex(kTRUE),
	fUseOwnXYZCalculation(kTRUE),
	fUseConstructGamma(kFALSE),
	kUseAODConversionPhoton(kTRUE),
	fCreateAOD(kFALSE),
	fDeltaAODBranchName("GammaConv"),
	fDeltaAODFilename("AliAODGammaConversion.root"),
	fRelabelAODs(kFALSE),
	fEventIsSelected(kFALSE),
	fNumberOfPrimaryTracks(0),
	fPeriodName("")
{
	// Default constructor

	DefineInput(0, TChain::Class());
}

//________________________________________________________________________
AliV0ReaderV1::~AliV0ReaderV1()
{
	// default deconstructor

	if(fConversionGammas){
		fConversionGammas->Delete();// Clear Objects
		delete fConversionGammas;
		fConversionGammas=0x0;
	}
}

/*
//________________________________________________________________________
AliV0ReaderV1::AliV0ReaderV1(AliV0ReaderV1 &original) : AliAnalysisTaskSE(original),
fConversionCuts(NULL),
fConversionGammas(NULL),
fUseImprovedVertex(original.fUseImprovedVertex),
fUseOwnXYZCalculation(original.fUseOwnXYZCalculation),
fUseConstructGamma(original.fUseConstructGamma),
kUseAODConversionPhoton(original.kUseAODConversionPhoton),
fCreateAOD(original.fCreateAOD),
fDeltaAODBranchName(original.fDeltaAODBranchName),
fDeltaAODFilename(original.fDeltaAODFilename),
fEventIsSelected(original.fEventIsSelected)
{
// Default constructor

DefineInput(0, TChain::Class());
}

//____________________________________________________________
AliV0ReaderV1 &AliV0ReaderV1::operator=(const AliV0ReaderV1 &ref){
//
// Assignment operator
// Only copies pointers, object is not the owner of the references
//
if(this != &ref){
AliAnalysisTaskSE::operator=(ref);
fUseImprovedVertex=ref.fUseImprovedVertex;
fUseOwnXYZCalculation=ref.fUseOwnXYZCalculation;
fUseConstructGamma=ref.fUseConstructGamma;
kUseAODConversionPhoton=ref.kUseAODConversionPhoton;
fCreateAOD=ref.fCreateAOD;
fDeltaAODBranchName=ref.fDeltaAODBranchName;
fDeltaAODFilename=ref.fDeltaAODFilename;
fEventIsSelected=ref.fEventIsSelected;
}
return *this;
}
*/

//________________________________________________________________________
void AliV0ReaderV1::Init()
{
	// Initialize function to be called once before analysis
	if(fConversionCuts==NULL){
		if(fConversionCuts==NULL)AliError("No Conversion Cut Selection initialized");
	}
	if(fEventCuts==NULL){
		if(fEventCuts==NULL)AliError("No Event Cut Selection initialized");
	}

	if(fCreateAOD){kUseAODConversionPhoton=kTRUE;}

	if(fConversionGammas != NULL){
		delete fConversionGammas;
		fConversionGammas=NULL;
	}

	if(fConversionGammas == NULL){
		if(kUseAODConversionPhoton){
			fConversionGammas = new TClonesArray("AliAODConversionPhoton",100);}
		else{
			fConversionGammas = new TClonesArray("AliKFConversionPhoton",100);}
	}
	fConversionGammas->Delete();//Reset the TClonesArray
}

//________________________________________________________________________
void AliV0ReaderV1::UserCreateOutputObjects()
{
	// Create AODs

	if(fCreateAOD){
		if (fEventCuts){
			fDeltaAODBranchName.Append("_");
			fDeltaAODBranchName.Append(fEventCuts->GetCutNumber());	
		}	
		if(fConversionCuts){
			fDeltaAODBranchName.Append("_");
			fDeltaAODBranchName.Append(fConversionCuts->GetCutNumber());
			fDeltaAODBranchName.Append("_gamma");
		}
		fConversionGammas->SetName(fDeltaAODBranchName.Data());

		AddAODBranch("TClonesArray", &fConversionGammas, fDeltaAODFilename.Data());
		AliAnalysisManager::GetAnalysisManager()->RegisterExtraFile(fDeltaAODFilename.Data());
	}

}
//________________________________________________________________________
Bool_t AliV0ReaderV1::Notify()
{
	if (fPeriodName.CompareTo("") == 0){
		AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
		if(man) {
			AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
			if (inputHandler){
				TTree* tree = (TTree*) inputHandler->GetTree();
				TFile* file = (TFile*) tree->GetCurrentFile();
				TString fileName(file->GetName());
				TObjArray *arr = fileName.Tokenize("/");
				for (Int_t i = 0; i < arr->GetEntriesFast();i++ ){
				TObjString* testObjString = (TObjString*)arr->At(i);
				if (testObjString->GetString().Contains("LHC")){
					fPeriodName = testObjString->GetString();
					i = arr->GetEntriesFast();
				}
				}
			}
		}
		if(!fEventCuts->GetDoEtaShift()) return kTRUE; // No Eta Shift requested, continue
		if(fEventCuts->GetEtaShift() == 0.0){ // Eta Shift requested but not set, get shift automatically
			fEventCuts->GetCorrectEtaShiftFromPeriod(fPeriodName);
			fEventCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
			return kTRUE;
		} else {
			printf(" Gamma Conversion Reader %s_%s :: Eta Shift Manually Set to %f \n\n",
					(fEventCuts->GetCutNumber()).Data(),(fConversionCuts->GetCutNumber()).Data(),fEventCuts->GetEtaShift());
			fEventCuts->DoEtaShift(kFALSE); // Eta Shift Set, make sure that it is called only once
		}
	}
	return kTRUE;
}
//________________________________________________________________________
void AliV0ReaderV1::UserExec(Option_t *option){

	AliESDEvent * esdEvent = dynamic_cast<AliESDEvent*>(fInputEvent);
	if(esdEvent) {
		if (!TGeoGlobalMagField::Instance()->GetField()) esdEvent->InitMagneticField(); 
	}

	// Check if correctly initialized
	if(!fConversionGammas)Init();

	// User Exec
	fEventIsSelected=ProcessEvent(fInputEvent,fMCEvent);

	// AOD Output
	FillAODOutput();
	
}

//________________________________________________________________________
Bool_t AliV0ReaderV1::ProcessEvent(AliVEvent *inputEvent,AliMCEvent *mcEvent)
{

	//Reset the TClonesArray
	fConversionGammas->Delete();

	fInputEvent=inputEvent;
	fMCEvent=mcEvent;

	if(!fInputEvent){
		AliError("No Input event");
		return kFALSE;
	}
	if(!fEventCuts){AliError("No EventCuts");return kFALSE;}
	if(!fConversionCuts){AliError("No ConversionCuts");return kFALSE;}

	// Count Primary Tracks Event
	CountTracks();

	// Event Cuts
	if(!fEventCuts->EventIsSelected(fInputEvent,fMCEvent))return kFALSE;

	// Set Magnetic Field
	AliKFParticle::SetField(fInputEvent->GetMagneticField());

	if(fInputEvent->IsA()==AliESDEvent::Class()){
		ProcessESDV0s();
	}
	if(fInputEvent->IsA()==AliAODEvent::Class()){
		GetAODConversionGammas();
	}

	return kTRUE;
}
///________________________________________________________________________
void AliV0ReaderV1::FillAODOutput()
{
   // Fill AOD Output with reconstructed Photons

	if(fInputEvent->IsA()==AliESDEvent::Class()){
		///Make sure delta aod is filled if standard aod is filled (for synchronization when reading aod with standard aod)
		if(fCreateAOD) {
			AliAODHandler * aodhandler = dynamic_cast<AliAODHandler*>(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler());
			if (aodhandler && aodhandler->GetFillAOD()) {
				AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()->SetFillExtension(kTRUE);
				//PostData(0, fConversionGammas);

			}
		}
	}
}

///________________________________________________________________________
const AliExternalTrackParam *AliV0ReaderV1::GetExternalTrackParam(AliESDv0 *fCurrentV0,Int_t &tracklabel,Int_t charge){

	// Get External Track Parameter with given charge

	if(!(charge==1||charge==-1)){AliError("Charge not defined");return 0x0;}

	// Check for sign flip
	if(fCurrentV0){
		if(!fCurrentV0->GetParamN()||!fCurrentV0->GetParamP())return 0x0;
		if(!fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex())||!fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))return 0x0;
		if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetPindex()))->Charge()==charge){
			tracklabel=fCurrentV0->GetPindex();
			return fCurrentV0->GetParamP();}
		if((fConversionCuts->GetTrack(fInputEvent,fCurrentV0->GetNindex()))->Charge()==charge){
			tracklabel=fCurrentV0->GetNindex();
			return fCurrentV0->GetParamN();}
	}
	return 0x0;
}

///________________________________________________________________________
Bool_t AliV0ReaderV1::ProcessESDV0s()
{
	// Process ESD V0s for conversion photon reconstruction
	AliESDEvent *fESDEvent=dynamic_cast<AliESDEvent*>(fInputEvent);

	AliKFConversionPhoton *fCurrentMotherKFCandidate=NULL;

	if(fESDEvent){

		for(Int_t currentV0Index=0;currentV0Index<fESDEvent->GetNumberOfV0s();currentV0Index++){
			AliESDv0 *fCurrentV0=(AliESDv0*)(fESDEvent->GetV0(currentV0Index));
			if(!fCurrentV0){
				printf("Requested V0 does not exist");
				continue;
			}

			fCurrentMotherKFCandidate=ReconstructV0(fCurrentV0,currentV0Index);

			if(fCurrentMotherKFCandidate){
				// Add Gamma to the TClonesArray

				if(kUseAODConversionPhoton){
				new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliAODConversionPhoton(fCurrentMotherKFCandidate);
				AliAODConversionPhoton * currentConversionPhoton = (AliAODConversionPhoton*)(fConversionGammas->At(fConversionGammas->GetEntriesFast()-1));
				currentConversionPhoton->SetMass(fCurrentMotherKFCandidate->M());
				currentConversionPhoton->SetMassToZero();

				}
				else{
				new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliKFConversionPhoton(*fCurrentMotherKFCandidate);
				}

				delete fCurrentMotherKFCandidate;
				fCurrentMotherKFCandidate=NULL;
			}
		}
	}
	return kTRUE;
}

///________________________________________________________________________
AliKFConversionPhoton *AliV0ReaderV1::ReconstructV0(AliESDv0 *fCurrentV0,Int_t currentV0Index)
{
	//   cout << currentV0Index << endl;
	// Reconstruct conversion photon from ESD v0
	fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonIn);

	//checks if on the fly mode is set
	if(!fConversionCuts->SelectV0Finder(fCurrentV0->GetOnFlyStatus())){
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kOnFly);
		return 0x0;
	}
	
	// TrackLabels
	Int_t currentTrackLabels[2]={-1,-1};

	// Get Daughter KF Particles

	const AliExternalTrackParam *fCurrentExternalTrackParamPositive=GetExternalTrackParamP(fCurrentV0,currentTrackLabels[0]);
	//    cout << fCurrentExternalTrackParamPositive << "\t" << currentTrackLabels[0] << endl;
	const AliExternalTrackParam *fCurrentExternalTrackParamNegative=GetExternalTrackParamN(fCurrentV0,currentTrackLabels[1]);
	//    cout << fCurrentExternalTrackParamNegative << "\t" << currentTrackLabels[1] << endl;
	if(!fCurrentExternalTrackParamPositive||!fCurrentExternalTrackParamNegative)return 0x0;

	// Apply some Cuts before Reconstruction

	AliVTrack * posTrack = fConversionCuts->GetTrack(fInputEvent,currentTrackLabels[0]);
	AliVTrack * negTrack = fConversionCuts->GetTrack(fInputEvent,currentTrackLabels[1]);
	if(!negTrack || !posTrack) {
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kNoTracks);
		return 0x0;
	}
	// Track Cuts
	if(!fConversionCuts->TracksAreSelected(negTrack, posTrack)){
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kTrackCuts);
		return 0x0;
	}
	
	fConversionCuts->FillV0EtaBeforedEdxCuts(fCurrentV0->Eta());
	if (!fConversionCuts->dEdxCuts(posTrack)) {
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kdEdxCuts);
		return 0x0;
	}
	// PID Cuts
	if(!fConversionCuts->dEdxCuts(negTrack)) {
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kdEdxCuts);
		return 0x0;
	}
	fConversionCuts->FillV0EtaAfterdEdxCuts(fCurrentV0->Eta());
	// Reconstruct Photon
	AliKFConversionPhoton *fCurrentMotherKF=NULL;
	//    fUseConstructGamma = kFALSE;
	//    cout << "construct gamma " << endl;
	AliKFParticle fCurrentNegativeKFParticle(*(fCurrentExternalTrackParamNegative),11);
	//    cout << fCurrentExternalTrackParamNegative << "\t" << endl;
	AliKFParticle fCurrentPositiveKFParticle(*(fCurrentExternalTrackParamPositive),-11);
	//    cout << fCurrentExternalTrackParamPositive << "\t"  << endl;
	//    cout << currentTrackLabels[0] << "\t" << currentTrackLabels[1] << endl;
	//    cout << "construct gamma " <<fUseConstructGamma << endl;
	
	// Reconstruct Gamma
	if(fUseConstructGamma){
		fCurrentMotherKF = new AliKFConversionPhoton();
		fCurrentMotherKF->ConstructGamma(fCurrentNegativeKFParticle,fCurrentPositiveKFParticle);
	}else{
		fCurrentMotherKF = new AliKFConversionPhoton(fCurrentNegativeKFParticle,fCurrentPositiveKFParticle);
		fCurrentMotherKF->SetMassConstraint(0,0.0001);
	}

	// Set Track Labels

	fCurrentMotherKF->SetTrackLabels(currentTrackLabels[0],currentTrackLabels[1]);

	// Set V0 index

	fCurrentMotherKF->SetV0Index(currentV0Index);

	//Set MC Label
	if(fMCEvent){

		AliStack *fMCStack= fMCEvent->Stack();

		Int_t labelp=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,fCurrentMotherKF->GetTrackLabelPositive())->GetLabel());
		Int_t labeln=TMath::Abs(fConversionCuts->GetTrack(fInputEvent,fCurrentMotherKF->GetTrackLabelNegative())->GetLabel());

		TParticle *fNegativeMCParticle = fMCStack->Particle(labeln);
		TParticle *fPositiveMCParticle = fMCStack->Particle(labelp);

		if(fPositiveMCParticle&&fNegativeMCParticle){
			fCurrentMotherKF->SetMCLabelPositive(labelp);
			fCurrentMotherKF->SetMCLabelNegative(labeln);
		}
	}

	// Update Vertex (moved for same eta compared to old)
	//      cout << currentV0Index <<" \t before: \t" << fCurrentMotherKF->GetPx() << "\t" << fCurrentMotherKF->GetPy() << "\t" << fCurrentMotherKF->GetPz()  << endl;
	if(fUseImprovedVertex == kTRUE){
		AliKFVertex primaryVertexImproved(*fInputEvent->GetPrimaryVertex());
		//        cout << "Prim Vtx: " << primaryVertexImproved.GetX() << "\t" << primaryVertexImproved.GetY() << "\t" << primaryVertexImproved.GetZ() << endl;
		primaryVertexImproved+=*fCurrentMotherKF;
		fCurrentMotherKF->SetProductionVertex(primaryVertexImproved);
	}
	// SetPsiPair

	Double_t PsiPair=GetPsiPair(fCurrentV0,fCurrentExternalTrackParamPositive,fCurrentExternalTrackParamNegative);
	fCurrentMotherKF->SetPsiPair(PsiPair);
	
	// Recalculate ConversionPoint
	Double_t dca[2]={0,0};
	if(fUseOwnXYZCalculation){
		Double_t convpos[3]={0,0,0};
		if(!GetConversionPoint(fCurrentExternalTrackParamPositive,fCurrentExternalTrackParamNegative,convpos,dca)){
			fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kConvPointFail);
			delete fCurrentMotherKF;
			fCurrentMotherKF=NULL;
			return 0x0;
		}

		fCurrentMotherKF->SetConversionPoint(convpos);
	}

	if(fCurrentMotherKF->GetNDF() > 0.)
		fCurrentMotherKF->SetChi2perNDF(fCurrentMotherKF->GetChi2()/fCurrentMotherKF->GetNDF());   //->Photon is created before all chi2 relevant changes are performed, set it "by hand"


	// Set Dilepton Mass (moved down for same eta compared to old)
	fCurrentMotherKF->SetMass(fCurrentMotherKF->M());

	// Apply Photon Cuts

	if(!fConversionCuts->PhotonCuts(fCurrentMotherKF,fInputEvent)){
		fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonCuts);
		delete fCurrentMotherKF;
		fCurrentMotherKF=NULL;
		return 0x0;
	}

	//    cout << currentV0Index <<" \t after: \t" <<fCurrentMotherKF->GetPx() << "\t" << fCurrentMotherKF->GetPy() << "\t" << fCurrentMotherKF->GetPz()  << endl;

	fConversionCuts->FillPhotonCutIndex(AliConversionPhotonCuts::kPhotonOut);
	return fCurrentMotherKF;
}

///________________________________________________________________________
Double_t AliV0ReaderV1::GetPsiPair(const AliESDv0* v0, const AliExternalTrackParam *positiveparam,const AliExternalTrackParam *negativeparam) const {
	//
	// Angle between daughter momentum plane and plane
	//

	AliExternalTrackParam nt(*negativeparam);
	AliExternalTrackParam pt(*positiveparam);

	Float_t magField = fInputEvent->GetMagneticField();

	Double_t xyz[3] = {0.,0.,0.};
	v0->GetXYZ(xyz[0],xyz[1],xyz[2]);

	// Double_t pPlus[3]  = {pt.Px(),pt.Py(),pt.Pz()};
	// Double_t pMinus[3] = {nt.Px(),nt.Py(),nt.Pz()};

	// Double_t u[3] = {pPlus[0]+pMinus[0],pPlus[1]+pMinus[1],pPlus[2]+pMinus[2]};
	// Double_t normu = sqrt( (u[0]*u[0]) + (u[1]*u[1]) + (u[2]*u[2]) );

	// u[0] = u[0] / normu;
	// u[1] = u[1] / normu;
	// u[2] = u[2] / normu;

	// Double_t normpPlus = sqrt( (pPlus[0]*pPlus[0]) + (pPlus[1]*pPlus[1]) + (pPlus[2]*pPlus[2]) );
	// Double_t normpMinus = sqrt( (pMinus[0]*pMinus[0]) + (pMinus[1]*pMinus[1]) + (pMinus[2]*pMinus[2]) );

	// pPlus[0] = pPlus[0] / normpPlus;
	// pPlus[1] = pPlus[1] / normpPlus;
	// pPlus[2] = pPlus[2] / normpPlus;

	// pMinus[0] = pMinus[0] / normpMinus;
	// pMinus[1] = pMinus[1] / normpMinus;
	// pMinus[2] = pMinus[2] / normpMinus;

	// Double_t v[3] = {0,0,0}; // pPlus X pMinus
	// v[0] = (pPlus[1]*pMinus[2]) - (pPlus[2]*pMinus[1]);
	// v[1] = (pPlus[2]*pMinus[0]) - (pPlus[0]*pMinus[2]);
	// v[2] = (pPlus[0]*pMinus[1]) - (pPlus[1]*pMinus[0]);

	// Double_t w[3] = {0,0,0}; // u X v
	// w[0] = (u[1]*v[2]) - (u[2]*v[1]);
	// w[1] = (u[2]*v[0]) - (u[0]*v[2]);
	// w[2] = (u[0]*v[1]) - (u[1]*v[0]);

	// Double_t z[3] = {0,0,1};
	// Double_t wc[3] = {0,0,0}; // u X v
	// wc[0] = (u[1]*z[2]) - (u[2]*z[1]);
	// wc[1] = (u[2]*z[0]) - (u[0]*z[2]);
	// wc[2] = (u[0]*z[1]) - (u[1]*z[0]);

	// Double_t PhiV = TMath::ACos((w[0]*wc[0]) + (w[1]*wc[1]) + (w[2]*wc[2]));
	//return abs(PhiV);


	// TVector3 pPlus(pt.Px(),pt.Py(),pt.Pz());
	// TVector3 pMinus(nt.Px(),nt.Py(),nt.Pz());

	// TVector3 u = pMinus + pPlus;
	// u = u*(1/u.Mag());

	// TVector3 pHPlus = pPlus*(1/pPlus.Mag());
	// TVector3 pHMinus = pMinus*(1/pMinus.Mag());

	// TVector3 v = pHPlus.Cross(pHMinus);
	// TVector3 w = u.Cross(v);
	// TVector3 z(0,0,1);
	// TVector3 wc = u.Cross(z);

	// Double_t PhiV = w * wc;

	Double_t mn[3] = {0,0,0};
	Double_t mp[3] = {0,0,0};

	v0->GetNPxPyPz(mn[0],mn[1],mn[2]);//reconstructed cartesian momentum components of negative daughter;
	v0->GetPPxPyPz(mp[0],mp[1],mp[2]);//reconstructed cartesian momentum components of positive daughter;

	Double_t deltat = 1.;
	deltat = TMath::ATan(mp[2]/(TMath::Sqrt(mp[0]*mp[0] + mp[1]*mp[1])+1.e-13)) - TMath::ATan(mn[2]/(TMath::Sqrt(mn[0]*mn[0] + mn[1]*mn[1])+1.e-13));//difference of angles of the two daughter tracks with z-axis
	Double_t radiussum = TMath::Sqrt(xyz[0]*xyz[0] + xyz[1]*xyz[1]) + 50;//radius to which tracks shall be propagated

	Double_t momPosProp[3] = {0,0,0};
	Double_t momNegProp[3] = {0,0,0};

	Double_t psiPair = 4.;
	if(nt.PropagateTo(radiussum,magField) == 0) return psiPair; //propagate tracks to the outside -> Better Purity and Efficiency
	if(pt.PropagateTo(radiussum,magField) == 0) return psiPair; //propagate tracks to the outside -> Better Purity and Efficiency

	pt.GetPxPyPz(momPosProp);//Get momentum vectors of tracks after propagation
	nt.GetPxPyPz(momNegProp);

	Double_t pEle =
		TMath::Sqrt(momNegProp[0]*momNegProp[0]+momNegProp[1]*momNegProp[1]+momNegProp[2]*momNegProp[2]);//absolute momentum value of negative daughter

	Double_t pPos =
		TMath::Sqrt(momPosProp[0]*momPosProp[0]+momPosProp[1]*momPosProp[1]+momPosProp[2]*momPosProp[2]);//absolute momentum value of positive daughter

	Double_t scalarproduct =
		momPosProp[0]*momNegProp[0]+momPosProp[1]*momNegProp[1]+momPosProp[2]*momNegProp[2];//scalar product of propagated positive and negative daughters' momenta

	Double_t chipair = TMath::ACos(scalarproduct/(pEle*pPos));//Angle between propagated daughter tracks

	//    psiPair =  TMath::Abs(TMath::ASin(deltat/chipair));
	psiPair = TMath::ASin(deltat/chipair);
	return psiPair;
}

///________________________________________________________________________
Bool_t AliV0ReaderV1::GetHelixCenter(const AliExternalTrackParam *track,Double_t center[2]){

	// Get Center of the helix track parametrization

	Int_t charge=track->Charge();
	Double_t b=fInputEvent->GetMagneticField();

	Double_t	helix[6];
	track->GetHelixParameters(helix,b);

	Double_t xpos =	helix[5];
	Double_t ypos =	helix[0];
	Double_t radius = TMath::Abs(1./helix[4]);
	Double_t phi = helix[2];

	if(phi < 0){
		phi = phi + 2*TMath::Pi();
	}

	phi -= TMath::Pi()/2.;
	Double_t xpoint =	radius * TMath::Cos(phi);
	Double_t ypoint =	radius * TMath::Sin(phi);

	if(b<0){
		if(charge > 0){
			xpoint = - xpoint;
			ypoint = - ypoint;
		}
	}
	if(b>0){
		if(charge < 0){
			xpoint = - xpoint;
			ypoint = - ypoint;
		}
	}
	center[0] =	xpos + xpoint;
	center[1] =	ypos + ypoint;

	return 1;
}
///________________________________________________________________________
Bool_t AliV0ReaderV1::GetConversionPoint(const AliExternalTrackParam *pparam,const AliExternalTrackParam *nparam,Double_t convpos[3],Double_t dca[2]){

	// Recalculate Conversion Point

	if(!pparam||!nparam)return kFALSE;

	Double_t helixcenterpos[2];
	GetHelixCenter(pparam,helixcenterpos);

	Double_t helixcenterneg[2];
	GetHelixCenter(nparam,helixcenterneg);

	Double_t helixpos[6];
	pparam->GetHelixParameters(helixpos,fInputEvent->GetMagneticField());
	Double_t posradius = TMath::Abs(1./helixpos[4]);

	Double_t helixneg[6];
	nparam->GetHelixParameters(helixneg,fInputEvent->GetMagneticField());
	Double_t negradius = TMath::Abs(1./helixneg[4]);

	// Calculate xy-position

	Double_t xpos = helixcenterpos[0];
	Double_t ypos = helixcenterpos[1];
	Double_t xneg = helixcenterneg[0];
	Double_t yneg = helixcenterneg[1];

	convpos[0] = (xpos*negradius + xneg*posradius)/(negradius+posradius);
	convpos[1] = (ypos*negradius+ yneg*posradius)/(negradius+posradius);


	// Calculate Track XY vertex position

	Double_t deltaXPos = convpos[0] -	xpos;
	Double_t deltaYPos = convpos[1] -	ypos;

	Double_t deltaXNeg = convpos[0] -	xneg;
	Double_t deltaYNeg = convpos[1] -	yneg;

	Double_t alphaPos =	TMath::Pi() + TMath::ATan2(-deltaYPos,-deltaXPos);
	Double_t alphaNeg =	TMath::Pi() + TMath::ATan2(-deltaYNeg,-deltaXNeg);

	Double_t vertexXNeg =	xneg +	TMath::Abs(negradius)*TMath::Cos(alphaNeg);
	Double_t vertexYNeg =	yneg +	TMath::Abs(negradius)*TMath::Sin(alphaNeg);

	Double_t vertexXPos =	xpos +	TMath::Abs(posradius)*TMath::Cos(alphaPos);
	Double_t vertexYPos =	ypos +	TMath::Abs(posradius)*TMath::Sin(alphaPos);

	AliExternalTrackParam p(*pparam);
	AliExternalTrackParam n(*nparam);

	TVector2 vertexPos(vertexXPos,vertexYPos);
	TVector2 vertexNeg(vertexXNeg,vertexYNeg);

	// Convert to local coordinate system
	TVector2 vertexPosRot=vertexPos.Rotate(-p.GetAlpha());
	TVector2 vertexNegRot=vertexNeg.Rotate(-n.GetAlpha());

	// Propagate Track Params to Vertex

	if(!p.PropagateTo(vertexPosRot.X(),fInputEvent->GetMagneticField()))return kFALSE;
	if(!n.PropagateTo(vertexNegRot.X(),fInputEvent->GetMagneticField()))return kFALSE;

	// Check whether propagation was sucessful

	if(TMath::Abs(vertexPos.Mod()-TMath::Sqrt(p.GetX()*p.GetX()+p.GetY()*p.GetY()))>0.01)return kFALSE;
	if(TMath::Abs(vertexNeg.Mod()-TMath::Sqrt(n.GetX()*n.GetX()+n.GetY()*n.GetY()))>0.01)return kFALSE;

	// Calculate z position

	convpos[2] = (p.GetZ()*negradius+n.GetZ()*posradius)/(negradius+posradius);

	// Calculate DCA
	TVector2 vdca=vertexPos-vertexNeg;
	dca[0]=vdca.Mod();
	dca[1]=TMath::Abs(n.GetZ()-p.GetZ());

	return kTRUE;
	}
	//________________________________________________________________________
	Bool_t AliV0ReaderV1::GetAODConversionGammas(){

	// Get reconstructed conversion photons from satellite AOD file

	AliAODEvent *fAODEvent=dynamic_cast<AliAODEvent*>(fInputEvent);

	if(fAODEvent){

		if(fConversionGammas == NULL){
			fConversionGammas = new TClonesArray("AliAODConversionPhoton",100);
		}
		fConversionGammas->Delete();//Reset the TClonesArray

		//Get Gammas from satellite AOD gamma branch

		AliAODConversionPhoton *gamma=0x0;

		TClonesArray *fInputGammas=dynamic_cast<TClonesArray*>(fAODEvent->FindListObject(fDeltaAODBranchName.Data()));
		
		if(!fInputGammas){
			FindDeltaAODBranchName();
			fInputGammas=dynamic_cast<TClonesArray*>(fAODEvent->FindListObject(fDeltaAODBranchName.Data()));}
		if(!fInputGammas){AliError("No Gamma Satellites found");return kFALSE;}
		// Apply Selection Cuts to Gammas and create local working copy
		if(fInputGammas){
			for(Int_t i=0;i<fInputGammas->GetEntriesFast();i++){
				gamma=dynamic_cast<AliAODConversionPhoton*>(fInputGammas->At(i));
				if(gamma){
				if(fRelabelAODs)RelabelAODPhotonCandidates(gamma);
				if(fConversionCuts->PhotonIsSelected(gamma,fInputEvent)){
					new((*fConversionGammas)[fConversionGammas->GetEntriesFast()]) AliAODConversionPhoton(*gamma);}
				}
			}
		}
	}

	if(fConversionGammas->GetEntries()){return kTRUE;}

	return kFALSE;
}

//________________________________________________________________________
void AliV0ReaderV1::FindDeltaAODBranchName(){

	// Find delta AOD branchname containing reconstructed photons

	TList *list=fInputEvent->GetList();
	for(Int_t ii=0;ii<list->GetEntries();ii++){
		TString name((list->At(ii))->GetName());
		if(name.BeginsWith(fDeltaAODBranchName)&&name.EndsWith("gamma")){
			fDeltaAODBranchName=name;
			AliInfo(Form("Set DeltaAOD BranchName to: %s",fDeltaAODBranchName.Data()));
			return;
		}
	}
}
//________________________________________________________________________
void AliV0ReaderV1::RelabelAODPhotonCandidates(AliAODConversionPhoton *PhotonCandidate){

	// Relabeling For AOD Event
	// ESDiD -> AODiD
	// MCLabel -> AODMCLabel
	Bool_t AODLabelPos = kFALSE;
	Bool_t AODLabelNeg = kFALSE;

	for(Int_t i = 0; i<fInputEvent->GetNumberOfTracks();i++){
		AliAODTrack *tempDaughter = static_cast<AliAODTrack*>(fInputEvent->GetTrack(i));
		if(!AODLabelPos){
			if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelPositive() ){
				PhotonCandidate->SetMCLabelPositive(abs(tempDaughter->GetLabel()));
				PhotonCandidate->SetLabelPositive(i);
				AODLabelPos = kTRUE;
			}
		}
		if(!AODLabelNeg){
			if( tempDaughter->GetID() == PhotonCandidate->GetTrackLabelNegative()){
				PhotonCandidate->SetMCLabelNegative(abs(tempDaughter->GetLabel()));
				PhotonCandidate->SetLabelNegative(i);
				AODLabelNeg = kTRUE;
			}
		}
		if(AODLabelNeg && AODLabelPos){
			return;
		}
	}
	if(!AODLabelPos || !AODLabelNeg){
		AliError(Form("NO AOD Daughters Found Pos: %i %i Neg: %i %i",AODLabelPos,PhotonCandidate->GetTrackLabelPositive(),AODLabelNeg,PhotonCandidate->GetTrackLabelNegative()));
	}

}

//________________________________________________________________________
void AliV0ReaderV1::CountTracks(){

	// In Case of MC count only MB tracks
	// if(fMCEvent && fInputEvent->IsA()==AliESDEvent::Class()){
	//    fEventCuts->GetNotRejectedParticles(1,NULL,fMCEvent);   
	// }
	// if(fMCEvent && fInputEvent->IsA()==AliAODEvent::Class()){
	//    fEventCuts->GetNotRejectedParticles(1,NULL,fInputEvent);   
	// }
	
	if(fInputEvent->IsA()==AliESDEvent::Class()){
		// Using standard function for setting Cuts
		Bool_t selectPrimaries=kTRUE;
		AliESDtrackCuts *EsdTrackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(selectPrimaries);
		EsdTrackCuts->SetMaxDCAToVertexZ(2);
		EsdTrackCuts->SetEtaRange(-0.8, 0.8);
		EsdTrackCuts->SetPtRange(0.15);
		fNumberOfPrimaryTracks = 0;
		for(Int_t iTracks = 0; iTracks < fInputEvent->GetNumberOfTracks(); iTracks++){
			AliESDtrack* curTrack = (AliESDtrack*) fInputEvent->GetTrack(iTracks);
			if(!curTrack) continue;
			if(!EsdTrackCuts->AcceptTrack(curTrack)) continue;
			//if(fMCEvent && !(fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()),fMCEvent->Stack(),fInputEvent))) continue;
			fNumberOfPrimaryTracks++;
		}
		delete EsdTrackCuts;
		EsdTrackCuts=0x0;
	}
	else if(fInputEvent->IsA()==AliAODEvent::Class()){
		fNumberOfPrimaryTracks = 0;
		for(Int_t iTracks = 0; iTracks<fInputEvent->GetNumberOfTracks(); iTracks++){
			AliAODTrack* curTrack = (AliAODTrack*) fInputEvent->GetTrack(iTracks);
			if(curTrack->GetID()<0) continue; // Avoid double counting of tracks
			if(!curTrack->IsHybridGlobalConstrainedGlobal()) continue;
			if(abs(curTrack->Eta())>0.8) continue;
			if(curTrack->Pt()<0.15) continue;
			//if(fMCEvent && !(fEventCuts->IsParticleFromBGEvent(abs(curTrack->GetLabel()),NULL,fInputEvent))) continue;
			//if(abs(curTrack->ZAtDCA())>2) continue; // Only Set For TPCOnly tracks
			fNumberOfPrimaryTracks++;
		}
	}

	return;
}

//________________________________________________________________________
void AliV0ReaderV1::Terminate(Option_t *)
{

}
 AliV0ReaderV1.cxx:1
 AliV0ReaderV1.cxx:2
 AliV0ReaderV1.cxx:3
 AliV0ReaderV1.cxx:4
 AliV0ReaderV1.cxx:5
 AliV0ReaderV1.cxx:6
 AliV0ReaderV1.cxx:7
 AliV0ReaderV1.cxx:8
 AliV0ReaderV1.cxx:9
 AliV0ReaderV1.cxx:10
 AliV0ReaderV1.cxx:11
 AliV0ReaderV1.cxx:12
 AliV0ReaderV1.cxx:13
 AliV0ReaderV1.cxx:14
 AliV0ReaderV1.cxx:15
 AliV0ReaderV1.cxx:16
 AliV0ReaderV1.cxx:17
 AliV0ReaderV1.cxx:18
 AliV0ReaderV1.cxx:19
 AliV0ReaderV1.cxx:20
 AliV0ReaderV1.cxx:21
 AliV0ReaderV1.cxx:22
 AliV0ReaderV1.cxx:23
 AliV0ReaderV1.cxx:24
 AliV0ReaderV1.cxx:25
 AliV0ReaderV1.cxx:26
 AliV0ReaderV1.cxx:27
 AliV0ReaderV1.cxx:28
 AliV0ReaderV1.cxx:29
 AliV0ReaderV1.cxx:30
 AliV0ReaderV1.cxx:31
 AliV0ReaderV1.cxx:32
 AliV0ReaderV1.cxx:33
 AliV0ReaderV1.cxx:34
 AliV0ReaderV1.cxx:35
 AliV0ReaderV1.cxx:36
 AliV0ReaderV1.cxx:37
 AliV0ReaderV1.cxx:38
 AliV0ReaderV1.cxx:39
 AliV0ReaderV1.cxx:40
 AliV0ReaderV1.cxx:41
 AliV0ReaderV1.cxx:42
 AliV0ReaderV1.cxx:43
 AliV0ReaderV1.cxx:44
 AliV0ReaderV1.cxx:45
 AliV0ReaderV1.cxx:46
 AliV0ReaderV1.cxx:47
 AliV0ReaderV1.cxx:48
 AliV0ReaderV1.cxx:49
 AliV0ReaderV1.cxx:50
 AliV0ReaderV1.cxx:51
 AliV0ReaderV1.cxx:52
 AliV0ReaderV1.cxx:53
 AliV0ReaderV1.cxx:54
 AliV0ReaderV1.cxx:55
 AliV0ReaderV1.cxx:56
 AliV0ReaderV1.cxx:57
 AliV0ReaderV1.cxx:58
 AliV0ReaderV1.cxx:59
 AliV0ReaderV1.cxx:60
 AliV0ReaderV1.cxx:61
 AliV0ReaderV1.cxx:62
 AliV0ReaderV1.cxx:63
 AliV0ReaderV1.cxx:64
 AliV0ReaderV1.cxx:65
 AliV0ReaderV1.cxx:66
 AliV0ReaderV1.cxx:67
 AliV0ReaderV1.cxx:68
 AliV0ReaderV1.cxx:69
 AliV0ReaderV1.cxx:70
 AliV0ReaderV1.cxx:71
 AliV0ReaderV1.cxx:72
 AliV0ReaderV1.cxx:73
 AliV0ReaderV1.cxx:74
 AliV0ReaderV1.cxx:75
 AliV0ReaderV1.cxx:76
 AliV0ReaderV1.cxx:77
 AliV0ReaderV1.cxx:78
 AliV0ReaderV1.cxx:79
 AliV0ReaderV1.cxx:80
 AliV0ReaderV1.cxx:81
 AliV0ReaderV1.cxx:82
 AliV0ReaderV1.cxx:83
 AliV0ReaderV1.cxx:84
 AliV0ReaderV1.cxx:85
 AliV0ReaderV1.cxx:86
 AliV0ReaderV1.cxx:87
 AliV0ReaderV1.cxx:88
 AliV0ReaderV1.cxx:89
 AliV0ReaderV1.cxx:90
 AliV0ReaderV1.cxx:91
 AliV0ReaderV1.cxx:92
 AliV0ReaderV1.cxx:93
 AliV0ReaderV1.cxx:94
 AliV0ReaderV1.cxx:95
 AliV0ReaderV1.cxx:96
 AliV0ReaderV1.cxx:97
 AliV0ReaderV1.cxx:98
 AliV0ReaderV1.cxx:99
 AliV0ReaderV1.cxx:100
 AliV0ReaderV1.cxx:101
 AliV0ReaderV1.cxx:102
 AliV0ReaderV1.cxx:103
 AliV0ReaderV1.cxx:104
 AliV0ReaderV1.cxx:105
 AliV0ReaderV1.cxx:106
 AliV0ReaderV1.cxx:107
 AliV0ReaderV1.cxx:108
 AliV0ReaderV1.cxx:109
 AliV0ReaderV1.cxx:110
 AliV0ReaderV1.cxx:111
 AliV0ReaderV1.cxx:112
 AliV0ReaderV1.cxx:113
 AliV0ReaderV1.cxx:114
 AliV0ReaderV1.cxx:115
 AliV0ReaderV1.cxx:116
 AliV0ReaderV1.cxx:117
 AliV0ReaderV1.cxx:118
 AliV0ReaderV1.cxx:119
 AliV0ReaderV1.cxx:120
 AliV0ReaderV1.cxx:121
 AliV0ReaderV1.cxx:122
 AliV0ReaderV1.cxx:123
 AliV0ReaderV1.cxx:124
 AliV0ReaderV1.cxx:125
 AliV0ReaderV1.cxx:126
 AliV0ReaderV1.cxx:127
 AliV0ReaderV1.cxx:128
 AliV0ReaderV1.cxx:129
 AliV0ReaderV1.cxx:130
 AliV0ReaderV1.cxx:131
 AliV0ReaderV1.cxx:132
 AliV0ReaderV1.cxx:133
 AliV0ReaderV1.cxx:134
 AliV0ReaderV1.cxx:135
 AliV0ReaderV1.cxx:136
 AliV0ReaderV1.cxx:137
 AliV0ReaderV1.cxx:138
 AliV0ReaderV1.cxx:139
 AliV0ReaderV1.cxx:140
 AliV0ReaderV1.cxx:141
 AliV0ReaderV1.cxx:142
 AliV0ReaderV1.cxx:143
 AliV0ReaderV1.cxx:144
 AliV0ReaderV1.cxx:145
 AliV0ReaderV1.cxx:146
 AliV0ReaderV1.cxx:147
 AliV0ReaderV1.cxx:148
 AliV0ReaderV1.cxx:149
 AliV0ReaderV1.cxx:150
 AliV0ReaderV1.cxx:151
 AliV0ReaderV1.cxx:152
 AliV0ReaderV1.cxx:153
 AliV0ReaderV1.cxx:154
 AliV0ReaderV1.cxx:155
 AliV0ReaderV1.cxx:156
 AliV0ReaderV1.cxx:157
 AliV0ReaderV1.cxx:158
 AliV0ReaderV1.cxx:159
 AliV0ReaderV1.cxx:160
 AliV0ReaderV1.cxx:161
 AliV0ReaderV1.cxx:162
 AliV0ReaderV1.cxx:163
 AliV0ReaderV1.cxx:164
 AliV0ReaderV1.cxx:165
 AliV0ReaderV1.cxx:166
 AliV0ReaderV1.cxx:167
 AliV0ReaderV1.cxx:168
 AliV0ReaderV1.cxx:169
 AliV0ReaderV1.cxx:170
 AliV0ReaderV1.cxx:171
 AliV0ReaderV1.cxx:172
 AliV0ReaderV1.cxx:173
 AliV0ReaderV1.cxx:174
 AliV0ReaderV1.cxx:175
 AliV0ReaderV1.cxx:176
 AliV0ReaderV1.cxx:177
 AliV0ReaderV1.cxx:178
 AliV0ReaderV1.cxx:179
 AliV0ReaderV1.cxx:180
 AliV0ReaderV1.cxx:181
 AliV0ReaderV1.cxx:182
 AliV0ReaderV1.cxx:183
 AliV0ReaderV1.cxx:184
 AliV0ReaderV1.cxx:185
 AliV0ReaderV1.cxx:186
 AliV0ReaderV1.cxx:187
 AliV0ReaderV1.cxx:188
 AliV0ReaderV1.cxx:189
 AliV0ReaderV1.cxx:190
 AliV0ReaderV1.cxx:191
 AliV0ReaderV1.cxx:192
 AliV0ReaderV1.cxx:193
 AliV0ReaderV1.cxx:194
 AliV0ReaderV1.cxx:195
 AliV0ReaderV1.cxx:196
 AliV0ReaderV1.cxx:197
 AliV0ReaderV1.cxx:198
 AliV0ReaderV1.cxx:199
 AliV0ReaderV1.cxx:200
 AliV0ReaderV1.cxx:201
 AliV0ReaderV1.cxx:202
 AliV0ReaderV1.cxx:203
 AliV0ReaderV1.cxx:204
 AliV0ReaderV1.cxx:205
 AliV0ReaderV1.cxx:206
 AliV0ReaderV1.cxx:207
 AliV0ReaderV1.cxx:208
 AliV0ReaderV1.cxx:209
 AliV0ReaderV1.cxx:210
 AliV0ReaderV1.cxx:211
 AliV0ReaderV1.cxx:212
 AliV0ReaderV1.cxx:213
 AliV0ReaderV1.cxx:214
 AliV0ReaderV1.cxx:215
 AliV0ReaderV1.cxx:216
 AliV0ReaderV1.cxx:217
 AliV0ReaderV1.cxx:218
 AliV0ReaderV1.cxx:219
 AliV0ReaderV1.cxx:220
 AliV0ReaderV1.cxx:221
 AliV0ReaderV1.cxx:222
 AliV0ReaderV1.cxx:223
 AliV0ReaderV1.cxx:224
 AliV0ReaderV1.cxx:225
 AliV0ReaderV1.cxx:226
 AliV0ReaderV1.cxx:227
 AliV0ReaderV1.cxx:228
 AliV0ReaderV1.cxx:229
 AliV0ReaderV1.cxx:230
 AliV0ReaderV1.cxx:231
 AliV0ReaderV1.cxx:232
 AliV0ReaderV1.cxx:233
 AliV0ReaderV1.cxx:234
 AliV0ReaderV1.cxx:235
 AliV0ReaderV1.cxx:236
 AliV0ReaderV1.cxx:237
 AliV0ReaderV1.cxx:238
 AliV0ReaderV1.cxx:239
 AliV0ReaderV1.cxx:240
 AliV0ReaderV1.cxx:241
 AliV0ReaderV1.cxx:242
 AliV0ReaderV1.cxx:243
 AliV0ReaderV1.cxx:244
 AliV0ReaderV1.cxx:245
 AliV0ReaderV1.cxx:246
 AliV0ReaderV1.cxx:247
 AliV0ReaderV1.cxx:248
 AliV0ReaderV1.cxx:249
 AliV0ReaderV1.cxx:250
 AliV0ReaderV1.cxx:251
 AliV0ReaderV1.cxx:252
 AliV0ReaderV1.cxx:253
 AliV0ReaderV1.cxx:254
 AliV0ReaderV1.cxx:255
 AliV0ReaderV1.cxx:256
 AliV0ReaderV1.cxx:257
 AliV0ReaderV1.cxx:258
 AliV0ReaderV1.cxx:259
 AliV0ReaderV1.cxx:260
 AliV0ReaderV1.cxx:261
 AliV0ReaderV1.cxx:262
 AliV0ReaderV1.cxx:263
 AliV0ReaderV1.cxx:264
 AliV0ReaderV1.cxx:265
 AliV0ReaderV1.cxx:266
 AliV0ReaderV1.cxx:267
 AliV0ReaderV1.cxx:268
 AliV0ReaderV1.cxx:269
 AliV0ReaderV1.cxx:270
 AliV0ReaderV1.cxx:271
 AliV0ReaderV1.cxx:272
 AliV0ReaderV1.cxx:273
 AliV0ReaderV1.cxx:274
 AliV0ReaderV1.cxx:275
 AliV0ReaderV1.cxx:276
 AliV0ReaderV1.cxx:277
 AliV0ReaderV1.cxx:278
 AliV0ReaderV1.cxx:279
 AliV0ReaderV1.cxx:280
 AliV0ReaderV1.cxx:281
 AliV0ReaderV1.cxx:282
 AliV0ReaderV1.cxx:283
 AliV0ReaderV1.cxx:284
 AliV0ReaderV1.cxx:285
 AliV0ReaderV1.cxx:286
 AliV0ReaderV1.cxx:287
 AliV0ReaderV1.cxx:288
 AliV0ReaderV1.cxx:289
 AliV0ReaderV1.cxx:290
 AliV0ReaderV1.cxx:291
 AliV0ReaderV1.cxx:292
 AliV0ReaderV1.cxx:293
 AliV0ReaderV1.cxx:294
 AliV0ReaderV1.cxx:295
 AliV0ReaderV1.cxx:296
 AliV0ReaderV1.cxx:297
 AliV0ReaderV1.cxx:298
 AliV0ReaderV1.cxx:299
 AliV0ReaderV1.cxx:300
 AliV0ReaderV1.cxx:301
 AliV0ReaderV1.cxx:302
 AliV0ReaderV1.cxx:303
 AliV0ReaderV1.cxx:304
 AliV0ReaderV1.cxx:305
 AliV0ReaderV1.cxx:306
 AliV0ReaderV1.cxx:307
 AliV0ReaderV1.cxx:308
 AliV0ReaderV1.cxx:309
 AliV0ReaderV1.cxx:310
 AliV0ReaderV1.cxx:311
 AliV0ReaderV1.cxx:312
 AliV0ReaderV1.cxx:313
 AliV0ReaderV1.cxx:314
 AliV0ReaderV1.cxx:315
 AliV0ReaderV1.cxx:316
 AliV0ReaderV1.cxx:317
 AliV0ReaderV1.cxx:318
 AliV0ReaderV1.cxx:319
 AliV0ReaderV1.cxx:320
 AliV0ReaderV1.cxx:321
 AliV0ReaderV1.cxx:322
 AliV0ReaderV1.cxx:323
 AliV0ReaderV1.cxx:324
 AliV0ReaderV1.cxx:325
 AliV0ReaderV1.cxx:326
 AliV0ReaderV1.cxx:327
 AliV0ReaderV1.cxx:328
 AliV0ReaderV1.cxx:329
 AliV0ReaderV1.cxx:330
 AliV0ReaderV1.cxx:331
 AliV0ReaderV1.cxx:332
 AliV0ReaderV1.cxx:333
 AliV0ReaderV1.cxx:334
 AliV0ReaderV1.cxx:335
 AliV0ReaderV1.cxx:336
 AliV0ReaderV1.cxx:337
 AliV0ReaderV1.cxx:338
 AliV0ReaderV1.cxx:339
 AliV0ReaderV1.cxx:340
 AliV0ReaderV1.cxx:341
 AliV0ReaderV1.cxx:342
 AliV0ReaderV1.cxx:343
 AliV0ReaderV1.cxx:344
 AliV0ReaderV1.cxx:345
 AliV0ReaderV1.cxx:346
 AliV0ReaderV1.cxx:347
 AliV0ReaderV1.cxx:348
 AliV0ReaderV1.cxx:349
 AliV0ReaderV1.cxx:350
 AliV0ReaderV1.cxx:351
 AliV0ReaderV1.cxx:352
 AliV0ReaderV1.cxx:353
 AliV0ReaderV1.cxx:354
 AliV0ReaderV1.cxx:355
 AliV0ReaderV1.cxx:356
 AliV0ReaderV1.cxx:357
 AliV0ReaderV1.cxx:358
 AliV0ReaderV1.cxx:359
 AliV0ReaderV1.cxx:360
 AliV0ReaderV1.cxx:361
 AliV0ReaderV1.cxx:362
 AliV0ReaderV1.cxx:363
 AliV0ReaderV1.cxx:364
 AliV0ReaderV1.cxx:365
 AliV0ReaderV1.cxx:366
 AliV0ReaderV1.cxx:367
 AliV0ReaderV1.cxx:368
 AliV0ReaderV1.cxx:369
 AliV0ReaderV1.cxx:370
 AliV0ReaderV1.cxx:371
 AliV0ReaderV1.cxx:372
 AliV0ReaderV1.cxx:373
 AliV0ReaderV1.cxx:374
 AliV0ReaderV1.cxx:375
 AliV0ReaderV1.cxx:376
 AliV0ReaderV1.cxx:377
 AliV0ReaderV1.cxx:378
 AliV0ReaderV1.cxx:379
 AliV0ReaderV1.cxx:380
 AliV0ReaderV1.cxx:381
 AliV0ReaderV1.cxx:382
 AliV0ReaderV1.cxx:383
 AliV0ReaderV1.cxx:384
 AliV0ReaderV1.cxx:385
 AliV0ReaderV1.cxx:386
 AliV0ReaderV1.cxx:387
 AliV0ReaderV1.cxx:388
 AliV0ReaderV1.cxx:389
 AliV0ReaderV1.cxx:390
 AliV0ReaderV1.cxx:391
 AliV0ReaderV1.cxx:392
 AliV0ReaderV1.cxx:393
 AliV0ReaderV1.cxx:394
 AliV0ReaderV1.cxx:395
 AliV0ReaderV1.cxx:396
 AliV0ReaderV1.cxx:397
 AliV0ReaderV1.cxx:398
 AliV0ReaderV1.cxx:399
 AliV0ReaderV1.cxx:400
 AliV0ReaderV1.cxx:401
 AliV0ReaderV1.cxx:402
 AliV0ReaderV1.cxx:403
 AliV0ReaderV1.cxx:404
 AliV0ReaderV1.cxx:405
 AliV0ReaderV1.cxx:406
 AliV0ReaderV1.cxx:407
 AliV0ReaderV1.cxx:408
 AliV0ReaderV1.cxx:409
 AliV0ReaderV1.cxx:410
 AliV0ReaderV1.cxx:411
 AliV0ReaderV1.cxx:412
 AliV0ReaderV1.cxx:413
 AliV0ReaderV1.cxx:414
 AliV0ReaderV1.cxx:415
 AliV0ReaderV1.cxx:416
 AliV0ReaderV1.cxx:417
 AliV0ReaderV1.cxx:418
 AliV0ReaderV1.cxx:419
 AliV0ReaderV1.cxx:420
 AliV0ReaderV1.cxx:421
 AliV0ReaderV1.cxx:422
 AliV0ReaderV1.cxx:423
 AliV0ReaderV1.cxx:424
 AliV0ReaderV1.cxx:425
 AliV0ReaderV1.cxx:426
 AliV0ReaderV1.cxx:427
 AliV0ReaderV1.cxx:428
 AliV0ReaderV1.cxx:429
 AliV0ReaderV1.cxx:430
 AliV0ReaderV1.cxx:431
 AliV0ReaderV1.cxx:432
 AliV0ReaderV1.cxx:433
 AliV0ReaderV1.cxx:434
 AliV0ReaderV1.cxx:435
 AliV0ReaderV1.cxx:436
 AliV0ReaderV1.cxx:437
 AliV0ReaderV1.cxx:438
 AliV0ReaderV1.cxx:439
 AliV0ReaderV1.cxx:440
 AliV0ReaderV1.cxx:441
 AliV0ReaderV1.cxx:442
 AliV0ReaderV1.cxx:443
 AliV0ReaderV1.cxx:444
 AliV0ReaderV1.cxx:445
 AliV0ReaderV1.cxx:446
 AliV0ReaderV1.cxx:447
 AliV0ReaderV1.cxx:448
 AliV0ReaderV1.cxx:449
 AliV0ReaderV1.cxx:450
 AliV0ReaderV1.cxx:451
 AliV0ReaderV1.cxx:452
 AliV0ReaderV1.cxx:453
 AliV0ReaderV1.cxx:454
 AliV0ReaderV1.cxx:455
 AliV0ReaderV1.cxx:456
 AliV0ReaderV1.cxx:457
 AliV0ReaderV1.cxx:458
 AliV0ReaderV1.cxx:459
 AliV0ReaderV1.cxx:460
 AliV0ReaderV1.cxx:461
 AliV0ReaderV1.cxx:462
 AliV0ReaderV1.cxx:463
 AliV0ReaderV1.cxx:464
 AliV0ReaderV1.cxx:465
 AliV0ReaderV1.cxx:466
 AliV0ReaderV1.cxx:467
 AliV0ReaderV1.cxx:468
 AliV0ReaderV1.cxx:469
 AliV0ReaderV1.cxx:470
 AliV0ReaderV1.cxx:471
 AliV0ReaderV1.cxx:472
 AliV0ReaderV1.cxx:473
 AliV0ReaderV1.cxx:474
 AliV0ReaderV1.cxx:475
 AliV0ReaderV1.cxx:476
 AliV0ReaderV1.cxx:477
 AliV0ReaderV1.cxx:478
 AliV0ReaderV1.cxx:479
 AliV0ReaderV1.cxx:480
 AliV0ReaderV1.cxx:481
 AliV0ReaderV1.cxx:482
 AliV0ReaderV1.cxx:483
 AliV0ReaderV1.cxx:484
 AliV0ReaderV1.cxx:485
 AliV0ReaderV1.cxx:486
 AliV0ReaderV1.cxx:487
 AliV0ReaderV1.cxx:488
 AliV0ReaderV1.cxx:489
 AliV0ReaderV1.cxx:490
 AliV0ReaderV1.cxx:491
 AliV0ReaderV1.cxx:492
 AliV0ReaderV1.cxx:493
 AliV0ReaderV1.cxx:494
 AliV0ReaderV1.cxx:495
 AliV0ReaderV1.cxx:496
 AliV0ReaderV1.cxx:497
 AliV0ReaderV1.cxx:498
 AliV0ReaderV1.cxx:499
 AliV0ReaderV1.cxx:500
 AliV0ReaderV1.cxx:501
 AliV0ReaderV1.cxx:502
 AliV0ReaderV1.cxx:503
 AliV0ReaderV1.cxx:504
 AliV0ReaderV1.cxx:505
 AliV0ReaderV1.cxx:506
 AliV0ReaderV1.cxx:507
 AliV0ReaderV1.cxx:508
 AliV0ReaderV1.cxx:509
 AliV0ReaderV1.cxx:510
 AliV0ReaderV1.cxx:511
 AliV0ReaderV1.cxx:512
 AliV0ReaderV1.cxx:513
 AliV0ReaderV1.cxx:514
 AliV0ReaderV1.cxx:515
 AliV0ReaderV1.cxx:516
 AliV0ReaderV1.cxx:517
 AliV0ReaderV1.cxx:518
 AliV0ReaderV1.cxx:519
 AliV0ReaderV1.cxx:520
 AliV0ReaderV1.cxx:521
 AliV0ReaderV1.cxx:522
 AliV0ReaderV1.cxx:523
 AliV0ReaderV1.cxx:524
 AliV0ReaderV1.cxx:525
 AliV0ReaderV1.cxx:526
 AliV0ReaderV1.cxx:527
 AliV0ReaderV1.cxx:528
 AliV0ReaderV1.cxx:529
 AliV0ReaderV1.cxx:530
 AliV0ReaderV1.cxx:531
 AliV0ReaderV1.cxx:532
 AliV0ReaderV1.cxx:533
 AliV0ReaderV1.cxx:534
 AliV0ReaderV1.cxx:535
 AliV0ReaderV1.cxx:536
 AliV0ReaderV1.cxx:537
 AliV0ReaderV1.cxx:538
 AliV0ReaderV1.cxx:539
 AliV0ReaderV1.cxx:540
 AliV0ReaderV1.cxx:541
 AliV0ReaderV1.cxx:542
 AliV0ReaderV1.cxx:543
 AliV0ReaderV1.cxx:544
 AliV0ReaderV1.cxx:545
 AliV0ReaderV1.cxx:546
 AliV0ReaderV1.cxx:547
 AliV0ReaderV1.cxx:548
 AliV0ReaderV1.cxx:549
 AliV0ReaderV1.cxx:550
 AliV0ReaderV1.cxx:551
 AliV0ReaderV1.cxx:552
 AliV0ReaderV1.cxx:553
 AliV0ReaderV1.cxx:554
 AliV0ReaderV1.cxx:555
 AliV0ReaderV1.cxx:556
 AliV0ReaderV1.cxx:557
 AliV0ReaderV1.cxx:558
 AliV0ReaderV1.cxx:559
 AliV0ReaderV1.cxx:560
 AliV0ReaderV1.cxx:561
 AliV0ReaderV1.cxx:562
 AliV0ReaderV1.cxx:563
 AliV0ReaderV1.cxx:564
 AliV0ReaderV1.cxx:565
 AliV0ReaderV1.cxx:566
 AliV0ReaderV1.cxx:567
 AliV0ReaderV1.cxx:568
 AliV0ReaderV1.cxx:569
 AliV0ReaderV1.cxx:570
 AliV0ReaderV1.cxx:571
 AliV0ReaderV1.cxx:572
 AliV0ReaderV1.cxx:573
 AliV0ReaderV1.cxx:574
 AliV0ReaderV1.cxx:575
 AliV0ReaderV1.cxx:576
 AliV0ReaderV1.cxx:577
 AliV0ReaderV1.cxx:578
 AliV0ReaderV1.cxx:579
 AliV0ReaderV1.cxx:580
 AliV0ReaderV1.cxx:581
 AliV0ReaderV1.cxx:582
 AliV0ReaderV1.cxx:583
 AliV0ReaderV1.cxx:584
 AliV0ReaderV1.cxx:585
 AliV0ReaderV1.cxx:586
 AliV0ReaderV1.cxx:587
 AliV0ReaderV1.cxx:588
 AliV0ReaderV1.cxx:589
 AliV0ReaderV1.cxx:590
 AliV0ReaderV1.cxx:591
 AliV0ReaderV1.cxx:592
 AliV0ReaderV1.cxx:593
 AliV0ReaderV1.cxx:594
 AliV0ReaderV1.cxx:595
 AliV0ReaderV1.cxx:596
 AliV0ReaderV1.cxx:597
 AliV0ReaderV1.cxx:598
 AliV0ReaderV1.cxx:599
 AliV0ReaderV1.cxx:600
 AliV0ReaderV1.cxx:601
 AliV0ReaderV1.cxx:602
 AliV0ReaderV1.cxx:603
 AliV0ReaderV1.cxx:604
 AliV0ReaderV1.cxx:605
 AliV0ReaderV1.cxx:606
 AliV0ReaderV1.cxx:607
 AliV0ReaderV1.cxx:608
 AliV0ReaderV1.cxx:609
 AliV0ReaderV1.cxx:610
 AliV0ReaderV1.cxx:611
 AliV0ReaderV1.cxx:612
 AliV0ReaderV1.cxx:613
 AliV0ReaderV1.cxx:614
 AliV0ReaderV1.cxx:615
 AliV0ReaderV1.cxx:616
 AliV0ReaderV1.cxx:617
 AliV0ReaderV1.cxx:618
 AliV0ReaderV1.cxx:619
 AliV0ReaderV1.cxx:620
 AliV0ReaderV1.cxx:621
 AliV0ReaderV1.cxx:622
 AliV0ReaderV1.cxx:623
 AliV0ReaderV1.cxx:624
 AliV0ReaderV1.cxx:625
 AliV0ReaderV1.cxx:626
 AliV0ReaderV1.cxx:627
 AliV0ReaderV1.cxx:628
 AliV0ReaderV1.cxx:629
 AliV0ReaderV1.cxx:630
 AliV0ReaderV1.cxx:631
 AliV0ReaderV1.cxx:632
 AliV0ReaderV1.cxx:633
 AliV0ReaderV1.cxx:634
 AliV0ReaderV1.cxx:635
 AliV0ReaderV1.cxx:636
 AliV0ReaderV1.cxx:637
 AliV0ReaderV1.cxx:638
 AliV0ReaderV1.cxx:639
 AliV0ReaderV1.cxx:640
 AliV0ReaderV1.cxx:641
 AliV0ReaderV1.cxx:642
 AliV0ReaderV1.cxx:643
 AliV0ReaderV1.cxx:644
 AliV0ReaderV1.cxx:645
 AliV0ReaderV1.cxx:646
 AliV0ReaderV1.cxx:647
 AliV0ReaderV1.cxx:648
 AliV0ReaderV1.cxx:649
 AliV0ReaderV1.cxx:650
 AliV0ReaderV1.cxx:651
 AliV0ReaderV1.cxx:652
 AliV0ReaderV1.cxx:653
 AliV0ReaderV1.cxx:654
 AliV0ReaderV1.cxx:655
 AliV0ReaderV1.cxx:656
 AliV0ReaderV1.cxx:657
 AliV0ReaderV1.cxx:658
 AliV0ReaderV1.cxx:659
 AliV0ReaderV1.cxx:660
 AliV0ReaderV1.cxx:661
 AliV0ReaderV1.cxx:662
 AliV0ReaderV1.cxx:663
 AliV0ReaderV1.cxx:664
 AliV0ReaderV1.cxx:665
 AliV0ReaderV1.cxx:666
 AliV0ReaderV1.cxx:667
 AliV0ReaderV1.cxx:668
 AliV0ReaderV1.cxx:669
 AliV0ReaderV1.cxx:670
 AliV0ReaderV1.cxx:671
 AliV0ReaderV1.cxx:672
 AliV0ReaderV1.cxx:673
 AliV0ReaderV1.cxx:674
 AliV0ReaderV1.cxx:675
 AliV0ReaderV1.cxx:676
 AliV0ReaderV1.cxx:677
 AliV0ReaderV1.cxx:678
 AliV0ReaderV1.cxx:679
 AliV0ReaderV1.cxx:680
 AliV0ReaderV1.cxx:681
 AliV0ReaderV1.cxx:682
 AliV0ReaderV1.cxx:683
 AliV0ReaderV1.cxx:684
 AliV0ReaderV1.cxx:685
 AliV0ReaderV1.cxx:686
 AliV0ReaderV1.cxx:687
 AliV0ReaderV1.cxx:688
 AliV0ReaderV1.cxx:689
 AliV0ReaderV1.cxx:690
 AliV0ReaderV1.cxx:691
 AliV0ReaderV1.cxx:692
 AliV0ReaderV1.cxx:693
 AliV0ReaderV1.cxx:694
 AliV0ReaderV1.cxx:695
 AliV0ReaderV1.cxx:696
 AliV0ReaderV1.cxx:697
 AliV0ReaderV1.cxx:698
 AliV0ReaderV1.cxx:699
 AliV0ReaderV1.cxx:700
 AliV0ReaderV1.cxx:701
 AliV0ReaderV1.cxx:702
 AliV0ReaderV1.cxx:703
 AliV0ReaderV1.cxx:704
 AliV0ReaderV1.cxx:705
 AliV0ReaderV1.cxx:706
 AliV0ReaderV1.cxx:707
 AliV0ReaderV1.cxx:708
 AliV0ReaderV1.cxx:709
 AliV0ReaderV1.cxx:710
 AliV0ReaderV1.cxx:711
 AliV0ReaderV1.cxx:712
 AliV0ReaderV1.cxx:713
 AliV0ReaderV1.cxx:714
 AliV0ReaderV1.cxx:715
 AliV0ReaderV1.cxx:716
 AliV0ReaderV1.cxx:717
 AliV0ReaderV1.cxx:718
 AliV0ReaderV1.cxx:719
 AliV0ReaderV1.cxx:720
 AliV0ReaderV1.cxx:721
 AliV0ReaderV1.cxx:722
 AliV0ReaderV1.cxx:723
 AliV0ReaderV1.cxx:724
 AliV0ReaderV1.cxx:725
 AliV0ReaderV1.cxx:726
 AliV0ReaderV1.cxx:727
 AliV0ReaderV1.cxx:728
 AliV0ReaderV1.cxx:729
 AliV0ReaderV1.cxx:730
 AliV0ReaderV1.cxx:731
 AliV0ReaderV1.cxx:732
 AliV0ReaderV1.cxx:733
 AliV0ReaderV1.cxx:734
 AliV0ReaderV1.cxx:735
 AliV0ReaderV1.cxx:736
 AliV0ReaderV1.cxx:737
 AliV0ReaderV1.cxx:738
 AliV0ReaderV1.cxx:739
 AliV0ReaderV1.cxx:740
 AliV0ReaderV1.cxx:741
 AliV0ReaderV1.cxx:742
 AliV0ReaderV1.cxx:743
 AliV0ReaderV1.cxx:744
 AliV0ReaderV1.cxx:745
 AliV0ReaderV1.cxx:746
 AliV0ReaderV1.cxx:747
 AliV0ReaderV1.cxx:748
 AliV0ReaderV1.cxx:749
 AliV0ReaderV1.cxx:750
 AliV0ReaderV1.cxx:751
 AliV0ReaderV1.cxx:752
 AliV0ReaderV1.cxx:753
 AliV0ReaderV1.cxx:754
 AliV0ReaderV1.cxx:755
 AliV0ReaderV1.cxx:756
 AliV0ReaderV1.cxx:757
 AliV0ReaderV1.cxx:758
 AliV0ReaderV1.cxx:759
 AliV0ReaderV1.cxx:760
 AliV0ReaderV1.cxx:761
 AliV0ReaderV1.cxx:762
 AliV0ReaderV1.cxx:763
 AliV0ReaderV1.cxx:764
 AliV0ReaderV1.cxx:765
 AliV0ReaderV1.cxx:766
 AliV0ReaderV1.cxx:767
 AliV0ReaderV1.cxx:768
 AliV0ReaderV1.cxx:769
 AliV0ReaderV1.cxx:770
 AliV0ReaderV1.cxx:771
 AliV0ReaderV1.cxx:772
 AliV0ReaderV1.cxx:773
 AliV0ReaderV1.cxx:774
 AliV0ReaderV1.cxx:775
 AliV0ReaderV1.cxx:776
 AliV0ReaderV1.cxx:777
 AliV0ReaderV1.cxx:778
 AliV0ReaderV1.cxx:779
 AliV0ReaderV1.cxx:780
 AliV0ReaderV1.cxx:781
 AliV0ReaderV1.cxx:782
 AliV0ReaderV1.cxx:783
 AliV0ReaderV1.cxx:784
 AliV0ReaderV1.cxx:785
 AliV0ReaderV1.cxx:786
 AliV0ReaderV1.cxx:787
 AliV0ReaderV1.cxx:788
 AliV0ReaderV1.cxx:789
 AliV0ReaderV1.cxx:790
 AliV0ReaderV1.cxx:791
 AliV0ReaderV1.cxx:792
 AliV0ReaderV1.cxx:793
 AliV0ReaderV1.cxx:794
 AliV0ReaderV1.cxx:795
 AliV0ReaderV1.cxx:796
 AliV0ReaderV1.cxx:797
 AliV0ReaderV1.cxx:798
 AliV0ReaderV1.cxx:799
 AliV0ReaderV1.cxx:800
 AliV0ReaderV1.cxx:801
 AliV0ReaderV1.cxx:802
 AliV0ReaderV1.cxx:803
 AliV0ReaderV1.cxx:804
 AliV0ReaderV1.cxx:805
 AliV0ReaderV1.cxx:806
 AliV0ReaderV1.cxx:807
 AliV0ReaderV1.cxx:808
 AliV0ReaderV1.cxx:809
 AliV0ReaderV1.cxx:810
 AliV0ReaderV1.cxx:811
 AliV0ReaderV1.cxx:812
 AliV0ReaderV1.cxx:813
 AliV0ReaderV1.cxx:814
 AliV0ReaderV1.cxx:815
 AliV0ReaderV1.cxx:816
 AliV0ReaderV1.cxx:817
 AliV0ReaderV1.cxx:818
 AliV0ReaderV1.cxx:819
 AliV0ReaderV1.cxx:820
 AliV0ReaderV1.cxx:821
 AliV0ReaderV1.cxx:822
 AliV0ReaderV1.cxx:823
 AliV0ReaderV1.cxx:824
 AliV0ReaderV1.cxx:825
 AliV0ReaderV1.cxx:826
 AliV0ReaderV1.cxx:827
 AliV0ReaderV1.cxx:828
 AliV0ReaderV1.cxx:829
 AliV0ReaderV1.cxx:830
 AliV0ReaderV1.cxx:831
 AliV0ReaderV1.cxx:832
 AliV0ReaderV1.cxx:833
 AliV0ReaderV1.cxx:834
 AliV0ReaderV1.cxx:835
 AliV0ReaderV1.cxx:836
 AliV0ReaderV1.cxx:837
 AliV0ReaderV1.cxx:838
 AliV0ReaderV1.cxx:839
 AliV0ReaderV1.cxx:840
 AliV0ReaderV1.cxx:841
 AliV0ReaderV1.cxx:842
 AliV0ReaderV1.cxx:843
 AliV0ReaderV1.cxx:844
 AliV0ReaderV1.cxx:845
 AliV0ReaderV1.cxx:846
 AliV0ReaderV1.cxx:847
 AliV0ReaderV1.cxx:848
 AliV0ReaderV1.cxx:849
 AliV0ReaderV1.cxx:850
 AliV0ReaderV1.cxx:851
 AliV0ReaderV1.cxx:852
 AliV0ReaderV1.cxx:853
 AliV0ReaderV1.cxx:854
 AliV0ReaderV1.cxx:855
 AliV0ReaderV1.cxx:856
 AliV0ReaderV1.cxx:857
 AliV0ReaderV1.cxx:858
 AliV0ReaderV1.cxx:859
 AliV0ReaderV1.cxx:860
 AliV0ReaderV1.cxx:861
 AliV0ReaderV1.cxx:862
 AliV0ReaderV1.cxx:863
 AliV0ReaderV1.cxx:864
 AliV0ReaderV1.cxx:865
 AliV0ReaderV1.cxx:866
 AliV0ReaderV1.cxx:867
 AliV0ReaderV1.cxx:868
 AliV0ReaderV1.cxx:869
 AliV0ReaderV1.cxx:870
 AliV0ReaderV1.cxx:871
 AliV0ReaderV1.cxx:872
 AliV0ReaderV1.cxx:873
 AliV0ReaderV1.cxx:874
 AliV0ReaderV1.cxx:875
 AliV0ReaderV1.cxx:876
 AliV0ReaderV1.cxx:877
 AliV0ReaderV1.cxx:878
 AliV0ReaderV1.cxx:879
 AliV0ReaderV1.cxx:880
 AliV0ReaderV1.cxx:881
 AliV0ReaderV1.cxx:882
 AliV0ReaderV1.cxx:883