[u/mrichter/AliRoot.git] / ANALYSIS / AliAOD.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.                  *
 **************************************************************************/

/* $Id$ */

/////////////////////////////////////////////////////////////
//
// base class for AOD containers
//
/////////////////////////////////////////////////////////////

#include <TROOT.h>
#include <TParticle.h>
#include <TClass.h>
#include <TString.h>

#include "AliAOD.h"
#include "AliAODParticle.h"
#include "AliTrackPoints.h"

ClassImp(AliAOD)

AliAOD::AliAOD():
 fParticles(0x0),
 fIsRandomized(kFALSE),
 fPrimaryVertexX(0.0),
 fPrimaryVertexY(0.0),
 fPrimaryVertexZ(0.0),
 fParticleClass(0x0)
{
 //ctor
// Info("AliAOD()","Entered");
// SetOwner(kTRUE);
// Info("AliAOD()","Exited");
}
/**************************************************************************/

AliAOD::AliAOD(const AliAOD& in):
 TObject(in),
 fParticles((TClonesArray*)in.fParticles->Clone()),
  fIsRandomized(in.fIsRandomized),
  fPrimaryVertexX(fPrimaryVertexX),
  fPrimaryVertexY(in.fPrimaryVertexY),
  fPrimaryVertexZ(in.fPrimaryVertexZ),
  fParticleClass(in.fParticleClass)
{
//copy constructor
}
/**************************************************************************/

AliAOD& AliAOD::operator=(const AliAOD& in)
{
//assigment operator  

  if (this == &in ) return *this;
  
  delete fParticles;
  fParticles = (TClonesArray*)in.fParticles->Clone();
  fIsRandomized = in.fIsRandomized ;
  fPrimaryVertexX = in.fPrimaryVertexX ;
  fPrimaryVertexY = in.fPrimaryVertexY ;
  fPrimaryVertexZ = in.fPrimaryVertexZ ;
  fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT
  return *this;
}
/**************************************************************************/

AliAOD::~AliAOD()
{
  //Destructor
  //fParticleClass does not belong to AliAOD -> Do not delete it
  delete fParticles;
  
}
/**************************************************************************/

void AliAOD::CopyData(AliAOD* aod)
{
 //Copys all data from aod, but leaves local type of particles
 if (aod == 0x0) return;
 if (aod == this) return;
 
 AliAOD& in = *this;
 
 fIsRandomized = in.fIsRandomized ;
 fPrimaryVertexX = in.fPrimaryVertexX ;
 fPrimaryVertexY = in.fPrimaryVertexY ;
 fPrimaryVertexZ = in.fPrimaryVertexZ ;
 fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT

 
 if (in.fParticles == 0x0)
  {//if in obj has null fParticles we delete ours
    delete fParticles;
    fParticles = 0x0;
  }
 else
  { 
    if (fParticles)
     { //if ours particles were already created
       if (fParticles->GetClass() != in.fParticles->GetClass())
        {//if in obj has 
          delete fParticles;
          fParticles = (TClonesArray*)in.fParticles->Clone();
        }
       else
        {
         //it should be faster than cloning
          Int_t inentr = in.fParticles->GetEntriesFast();
          Int_t curentr = fParticles->GetEntriesFast();

          TClonesArray& arr = *fParticles;

          //we have to take care about different sizes of arrays
          if ( curentr < inentr )
           {
             for (Int_t i = 0; i < curentr; i++)
              {
                TObject& inobj = *(in.fParticles->At(i));
                TObject& obj = *(fParticles->At(i));
                obj = inobj;
              }
             
             TClass* partclass = GetParticleClass();
             if (partclass == 0x0)
              {
                Fatal("CopyData","Can not get particle class");
                return;//pro forma
              }
              
             for (Int_t i = curentr; i < inentr; i++)
              {
                TObject& inobj = *(in.fParticles->At(i));
                TObject& obj =  *((TObject*)(partclass->New(arr[i])));
                obj = inobj;
              }
           }
          else 
           {
             for (Int_t i = 0; i < inentr; i++)
              {
                TObject& inobj = *(in.fParticles->At(i));
                TObject& obj = *(fParticles->At(i));
                obj = inobj;
              }
             
             for (Int_t i = curentr ; i >= inentr ; i--)
              {
                fParticles->RemoveAt(i);
              }
           }
        } 
     }
    else
     {
       fParticles = (TClonesArray*)in.fParticles->Clone();
     } 
  } 
 
}
/**************************************************************************/

void AliAOD::SetParticleClassName(const char* classname)
{
//Sets type of particle that is going to be stored 
  if (gROOT == 0x0) Fatal("SetParticleClassName","ROOT System not initialized");
  TClass* pclass = gROOT->GetClass(classname);
  if ( pclass == 0x0 )
   {
     Error("SetParticleClass","Can not get TClass for class named %s",classname);
     return;
   }
  SetParticleClass(pclass);
}
/**************************************************************************/

void AliAOD::SetParticleClass(TClass* pclass)
{
//Sets type of particle that is going to be stored 

  if ( pclass == 0x0 )
   {
     Error("SetParticleClass","Parameter is NULL.");
     return;
   }
   
  if ( pclass->InheritsFrom("AliVAODParticle") == kFALSE )
   {
     Error("SetParticleClass","Class named %s does not inherit from AliVAODParticle",pclass->GetName());
     return;
   }
  if (pclass != fParticleClass)
   {
     fParticleClass = pclass;
     if (fParticleClass) delete fParticles;
     fParticles = new TClonesArray(fParticleClass);
   }
}
/**************************************************************************/
TClass* AliAOD::GetParticleClass()
{
//returns TClass of particle class
  if (fParticleClass) return fParticleClass;
  
  if (fParticles == 0x0) return 0x0;
  
  fParticleClass = fParticles->GetClass();
  return fParticleClass;
}

/**************************************************************************/

void  AliAOD::AddParticle(TParticle* part, Int_t idx)
{
  //Adds TParticle to event
  if (part == 0x0) 
   {
     Error("AddParticle(TParticle*,Int_t)","pointer to particle is NULL");
     return;
   }

  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
  AddParticle( new AliAODParticle(*part,idx) );
}
/**************************************************************************/

void  AliAOD::AddParticle(AliVAODParticle* particle)
{
 //add particle to AOD
 //MAKES ITS OWN COPY OF THE PARTICLE!!! (AOD is not going to keep and delete input pointer)
 
  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");

  Int_t idx = fParticles->GetLast() + 1;
  TClonesArray& arr = *fParticles;

  TClass* partclass = GetParticleClass();
  if (partclass == 0x0)
   {
     Error("AddParticle(AliVAODParticle*)","Can not get particle class");
     return;
   }
  
  AliVAODParticle* pp = (AliVAODParticle*)partclass->New(arr[idx]);
  pp->operator=(*particle);
  
}
/**************************************************************************/

void  AliAOD::AddParticle(Int_t pdg, Int_t idx,
                          Double_t px, Double_t py, Double_t pz, Double_t etot,
                          Double_t vx, Double_t vy, Double_t vz, Double_t time)
{
  //adds particle to event (standard AOD class)

  if (fParticles == 0x0) SetParticleClassName("AliAODParticle");

  Int_t newpartidx = fParticles->GetLast() + 1;
  TClonesArray& arr = *fParticles;

  TClass* partclass = GetParticleClass();
  if (partclass == 0x0)
   {
     Error("AddParticle(Int_t,...)","Can not get particle class");
     return;
   }

  AliVAODParticle* p =  (AliVAODParticle*)partclass->New(arr[newpartidx]);
  
  p->SetPdgCode(pdg);
  p->SetUID(idx);
  p->SetMomentum(px,py,pz,etot);
  p->SetProductionVertex(vx,vy,vz,time);
  
}
/**************************************************************************/

void AliAOD::SwapParticles(Int_t i, Int_t j)
{
//swaps particles positions; used by AliHBTEvent::Blend
  if ( (i<0) || (i>=GetNumberOfParticles()) ) return;
  if ( (j<0) || (j>=GetNumberOfParticles()) ) return;
  

  TClass* partclass = GetParticleClass();
  if (partclass == 0x0)
   {
     Error("SwapParticles","Can not get particle class");
     return;
   }
    
  AliVAODParticle* tmpobj = (AliVAODParticle*)partclass->New();
  AliVAODParticle& tmp = *tmpobj;
  AliVAODParticle& first = *(GetParticle(i));
  AliVAODParticle& second = *(GetParticle(j));
  
  tmp = first;
  first = second;
  second = tmp;
  delete tmpobj;
}
/**************************************************************************/

void  AliAOD::Reset()
{
  //deletes all particles from the event
   if (fParticles) fParticles->Clear("C");
   
   fIsRandomized = kFALSE;
}
/**************************************************************************/

void AliAOD::GetPrimaryVertex(Double_t&x, Double_t&y, Double_t&z)
{
//returns positions of the primary vertex
  x = fPrimaryVertexX;
  y = fPrimaryVertexY;
  z = fPrimaryVertexZ;
}
/**************************************************************************/

void AliAOD::SetPrimaryVertex(Double_t x, Double_t y, Double_t z)
{
//Sets positions of the primary vertex 
  fPrimaryVertexX = x;
  fPrimaryVertexY = y;
  fPrimaryVertexZ = z;
}
/**************************************************************************/

Int_t AliAOD::GetNumberOfCharged(Double_t etamin, Double_t etamax) const
{
  //reurns number of charged particles within given pseudorapidity range
  Int_t n = 0;
  Int_t npart = GetNumberOfParticles();
  for (Int_t i = 0; i < npart; i++)
   {
     AliVAODParticle* p = GetParticle(i);
     Double_t eta = p->Eta();
     if ( (eta < etamin) || (eta > etamax) ) continue;
     if (p->Charge() != 0.0) n++;
   }
  return n;
}
/**************************************************************************/

void AliAOD::Move(Double_t x, Double_t y, Double_t z)
{
 //moves all spacial coordinates about this vector
 // vertex
 // track points
 // and whatever will be added to AOD and AOD particles that is a space coordinate

  fPrimaryVertexX += x;
  fPrimaryVertexY += y;
  fPrimaryVertexZ += z;

  Int_t npart = GetNumberOfParticles();
  for (Int_t i = 0; i < npart; i++)
   {
     AliVAODParticle* p = GetParticle(i);
     AliTrackPoints* tp  = p->GetTPCTrackPoints();
     if (tp) tp->Move(x,y,z);
     tp  = p->GetITSTrackPoints();
     if (tp) tp->Move(x,y,z);
   }
}
/**************************************************************************/

void AliAOD::Print(const Option_t* /*option*/) const
{
  //Prints AOD
  TString ts;
  TString msg("\n");
  msg+="Particle Class: ";
  if (fParticleClass)
   {
     msg+=fParticleClass->GetName();
   }
  else
   {
     msg+="Not specified yet";
   } 
  msg += "\n";
  msg += "Vertex position X: ";
  msg += fPrimaryVertexX;
  msg += " Y:" ;
  msg += fPrimaryVertexY;
  msg += " Z:";
  msg += fPrimaryVertexZ;
  msg += "\n";
  
  msg += "Randomized: ";
  msg += fIsRandomized;
  msg += "\n";
  
  Info("Print","%s",msg.Data());
  
  Int_t npart = GetNumberOfParticles();
  Info("Print","Npart: %d",npart);
  for (Int_t i = 0; i < npart; i++)
   {
     Info("Print","Getting particle %d",i);
     AliVAODParticle* p = GetParticle(i);
     Info("Print","Printing particle %d, address %#x",i,p);
     p->Dump();
     p->Print();
     Info("Print","particle %d printed",i);
   }
}

void AliAOD::SetOwner(Bool_t /*owner*/)
{
//Sets the ownership of particles: if particles should be also deleted if AOD is deleted/reseted
//Since fParticles is Clones and not Object Array, it is always the owner and this method does not have sense
 
 MayNotUse("SetOwner");
 //if fParticles->SetOwner(owner);
 
}
Commit	Line	Data
a5556ea5	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	/* $Id$ */
	17
	18	/////////////////////////////////////////////////////////////
	19	//
	20	// base class for AOD containers
	21	//
	22	/////////////////////////////////////////////////////////////
	23
7f03938c	24	#include <TROOT.h>
a5556ea5	25	#include <TParticle.h>
dd2b6810	26	#include <TClass.h>
dd2b6810	27	#include <TString.h>
d6a49f20	28
d6a49f20	29	#include "AliAOD.h"
afa8b37b	30	#include "AliAODParticle.h"
0d8a4589	31	#include "AliTrackPoints.h"
a5556ea5	32
	33	ClassImp(AliAOD)
	34
0d8a4589	35	AliAOD::AliAOD():
dd2b6810	36	fParticles(0x0),
0d8a4589	37	fIsRandomized(kFALSE),
	38	fPrimaryVertexX(0.0),
	39	fPrimaryVertexY(0.0),
dd2b6810	40	fPrimaryVertexZ(0.0),
dd2b6810	41	fParticleClass(0x0)
0d8a4589	42	{
0d8a4589	43	//ctor
dd2b6810	44	// Info("AliAOD()","Entered");
	45	// SetOwner(kTRUE);
	46	// Info("AliAOD()","Exited");
	47	}
	48	/**************************************************************************/
	49
efdb0cc9	50	AliAOD::AliAOD(const AliAOD& in):
	51	TObject(in),
	52	fParticles((TClonesArray*)in.fParticles->Clone()),
	53	fIsRandomized(in.fIsRandomized),
	54	fPrimaryVertexX(fPrimaryVertexX),
	55	fPrimaryVertexY(in.fPrimaryVertexY),
	56	fPrimaryVertexZ(in.fPrimaryVertexZ),
	57	fParticleClass(in.fParticleClass)
	58	{
	59	//copy constructor
	60	}
	61	/**************************************************************************/
	62
	63	AliAOD& AliAOD::operator=(const AliAOD& in)
	64	{
	65	//assigment operator
	66
	67	if (this == &in ) return *this;
	68
	69	delete fParticles;
	70	fParticles = (TClonesArray*)in.fParticles->Clone();
	71	fIsRandomized = in.fIsRandomized ;
	72	fPrimaryVertexX = in.fPrimaryVertexX ;
	73	fPrimaryVertexY = in.fPrimaryVertexY ;
	74	fPrimaryVertexZ = in.fPrimaryVertexZ ;
	75	fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT
	76	return *this;
	77	}
efdb0cc9	78	/**************************************************************************/
efdb0cc9	79
dd2b6810	80	AliAOD::~AliAOD()
	81	{
	82	//Destructor
	83	//fParticleClass does not belong to AliAOD -> Do not delete it
	84	delete fParticles;
	85
	86	}
	87	/**************************************************************************/
	88
efdb0cc9	89	void AliAOD::CopyData(AliAOD* aod)
	90	{
	91	//Copys all data from aod, but leaves local type of particles
	92	if (aod == 0x0) return;
	93	if (aod == this) return;
	94
	95	AliAOD& in = *this;
	96
	97	fIsRandomized = in.fIsRandomized ;
	98	fPrimaryVertexX = in.fPrimaryVertexX ;
	99	fPrimaryVertexY = in.fPrimaryVertexY ;
	100	fPrimaryVertexZ = in.fPrimaryVertexZ ;
	101	fParticleClass = in.fParticleClass ; //althought it is pointer, this points to object in class list of gROOT
	102
	103
	104	if (in.fParticles == 0x0)
	105	{//if in obj has null fParticles we delete ours
	106	delete fParticles;
	107	fParticles = 0x0;
	108	}
	109	else
	110	{
	111	if (fParticles)
	112	{ //if ours particles were already created
	113	if (fParticles->GetClass() != in.fParticles->GetClass())
	114	{//if in obj has
	115	delete fParticles;
	116	fParticles = (TClonesArray*)in.fParticles->Clone();
	117	}
	118	else
	119	{
	120	//it should be faster than cloning
	121	Int_t inentr = in.fParticles->GetEntriesFast();
	122	Int_t curentr = fParticles->GetEntriesFast();
	123
	124	TClonesArray& arr = *fParticles;
	125
	126	//we have to take care about different sizes of arrays
	127	if ( curentr < inentr )
	128	{
	129	for (Int_t i = 0; i < curentr; i++)
	130	{
	131	TObject& inobj = *(in.fParticles->At(i));
	132	TObject& obj = *(fParticles->At(i));
	133	obj = inobj;
	134	}
d9122a01	135
	136	TClass* partclass = GetParticleClass();
	137	if (partclass == 0x0)
	138	{
	139	Fatal("CopyData","Can not get particle class");
	140	return;//pro forma
	141	}
	142
efdb0cc9	143	for (Int_t i = curentr; i < inentr; i++)
	144	{
	145	TObject& inobj = *(in.fParticles->At(i));
d9122a01	146	TObject& obj = ((TObject)(partclass->New(arr[i])));
efdb0cc9	147	obj = inobj;
	148	}
	149	}
	150	else
	151	{
	152	for (Int_t i = 0; i < inentr; i++)
	153	{
	154	TObject& inobj = *(in.fParticles->At(i));
	155	TObject& obj = *(fParticles->At(i));
	156	obj = inobj;
	157	}
	158
	159	for (Int_t i = curentr ; i >= inentr ; i--)
	160	{
	161	fParticles->RemoveAt(i);
	162	}
	163	}
	164	}
	165	}
	166	else
	167	{
	168	fParticles = (TClonesArray*)in.fParticles->Clone();
	169	}
	170	}
	171
	172	}
	173	/**************************************************************************/
	174
dd2b6810	175	void AliAOD::SetParticleClassName(const char* classname)
	176	{
	177	//Sets type of particle that is going to be stored
	178	if (gROOT == 0x0) Fatal("SetParticleClassName","ROOT System not initialized");
	179	TClass* pclass = gROOT->GetClass(classname);
	180	if ( pclass == 0x0 )
	181	{
	182	Error("SetParticleClass","Can not get TClass for class named %s",classname);
	183	return;
	184	}
	185	SetParticleClass(pclass);
	186	}
	187	/**************************************************************************/
	188
	189	void AliAOD::SetParticleClass(TClass* pclass)
	190	{
	191	//Sets type of particle that is going to be stored
	192
	193	if ( pclass == 0x0 )
	194	{
	195	Error("SetParticleClass","Parameter is NULL.");
	196	return;
	197	}
	198
	199	if ( pclass->InheritsFrom("AliVAODParticle") == kFALSE )
	200	{
	201	Error("SetParticleClass","Class named %s does not inherit from AliVAODParticle",pclass->GetName());
	202	return;
	203	}
	204	if (pclass != fParticleClass)
	205	{
	206	fParticleClass = pclass;
	207	if (fParticleClass) delete fParticles;
	208	fParticles = new TClonesArray(fParticleClass);
	209	}
0d8a4589	210	}
d9122a01	211	/**************************************************************************/
	212	TClass* AliAOD::GetParticleClass()
	213	{
	214	//returns TClass of particle class
	215	if (fParticleClass) return fParticleClass;
	216
	217	if (fParticles == 0x0) return 0x0;
	218
	219	fParticleClass = fParticles->GetClass();
	220	return fParticleClass;
	221	}
0d8a4589	222
a5556ea5	223	/**************************************************************************/
	224
	225	void AliAOD::AddParticle(TParticle* part, Int_t idx)
	226	{
	227	//Adds TParticle to event
	228	if (part == 0x0)
	229	{
	230	Error("AddParticle(TParticle*,Int_t)","pointer to particle is NULL");
	231	return;
	232	}
dd2b6810	233
dd2b6810	234	if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
afa8b37b	235	AddParticle( new AliAODParticle(*part,idx) );
a5556ea5	236	}
	237	/**************************************************************************/
	238
dd2b6810	239	void AliAOD::AddParticle(AliVAODParticle* particle)
	240	{
	241	//add particle to AOD
	242	//MAKES ITS OWN COPY OF THE PARTICLE!!! (AOD is not going to keep and delete input pointer)
	243
	244	if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
	245
	246	Int_t idx = fParticles->GetLast() + 1;
	247	TClonesArray& arr = *fParticles;
d9122a01	248
	249	TClass* partclass = GetParticleClass();
	250	if (partclass == 0x0)
	251	{
	252	Error("AddParticle(AliVAODParticle*)","Can not get particle class");
	253	return;
	254	}
dd2b6810	255
d9122a01	256	AliVAODParticle* pp = (AliVAODParticle*)partclass->New(arr[idx]);
dd2b6810	257	pp->operator=(*particle);
	258
	259	}
	260	/**************************************************************************/
	261
a5556ea5	262	void AliAOD::AddParticle(Int_t pdg, Int_t idx,
	263	Double_t px, Double_t py, Double_t pz, Double_t etot,
	264	Double_t vx, Double_t vy, Double_t vz, Double_t time)
	265	{
dd2b6810	266	//adds particle to event (standard AOD class)
	267
	268	if (fParticles == 0x0) SetParticleClassName("AliAODParticle");
	269
	270	Int_t newpartidx = fParticles->GetLast() + 1;
	271	TClonesArray& arr = *fParticles;
d9122a01	272
	273	TClass* partclass = GetParticleClass();
	274	if (partclass == 0x0)
	275	{
	276	Error("AddParticle(Int_t,...)","Can not get particle class");
	277	return;
	278	}
	279
	280	AliVAODParticle* p = (AliVAODParticle*)partclass->New(arr[newpartidx]);
dd2b6810	281
	282	p->SetPdgCode(pdg);
	283	p->SetUID(idx);
	284	p->SetMomentum(px,py,pz,etot);
	285	p->SetProductionVertex(vx,vy,vz,time);
	286
a5556ea5	287	}
	288	/**************************************************************************/
	289
	290	void AliAOD::SwapParticles(Int_t i, Int_t j)
	291	{
	292	//swaps particles positions; used by AliHBTEvent::Blend
	293	if ( (i<0) \|\| (i>=GetNumberOfParticles()) ) return;
	294	if ( (j<0) \|\| (j>=GetNumberOfParticles()) ) return;
dd2b6810	295
d9122a01	296
	297	TClass* partclass = GetParticleClass();
	298	if (partclass == 0x0)
	299	{
	300	Error("SwapParticles","Can not get particle class");
	301	return;
	302	}
	303
	304	AliVAODParticle* tmpobj = (AliVAODParticle*)partclass->New();
dd2b6810	305	AliVAODParticle& tmp = *tmpobj;
	306	AliVAODParticle& first = *(GetParticle(i));
	307	AliVAODParticle& second = *(GetParticle(j));
	308
	309	tmp = first;
	310	first = second;
	311	second = tmp;
e1a64564	312	delete tmpobj;
a5556ea5	313	}
	314	/**************************************************************************/
	315
	316	void AliAOD::Reset()
	317	{
	318	//deletes all particles from the event
dd2b6810	319	if (fParticles) fParticles->Clear("C");
	320
	321	fIsRandomized = kFALSE;
a5556ea5	322	}
0d8a4589	323	/**************************************************************************/
	324
	325	void AliAOD::GetPrimaryVertex(Double_t&x, Double_t&y, Double_t&z)
	326	{
	327	//returns positions of the primary vertex
	328	x = fPrimaryVertexX;
	329	y = fPrimaryVertexY;
	330	z = fPrimaryVertexZ;
	331	}
	332	/**************************************************************************/
	333
	334	void AliAOD::SetPrimaryVertex(Double_t x, Double_t y, Double_t z)
	335	{
	336	//Sets positions of the primary vertex
	337	fPrimaryVertexX = x;
	338	fPrimaryVertexY = y;
	339	fPrimaryVertexZ = z;
	340	}
	341	/**************************************************************************/
	342
	343	Int_t AliAOD::GetNumberOfCharged(Double_t etamin, Double_t etamax) const
	344	{
	345	//reurns number of charged particles within given pseudorapidity range
29e00d75	346	Int_t n = 0;
dd2b6810	347	Int_t npart = GetNumberOfParticles();
0d8a4589	348	for (Int_t i = 0; i < npart; i++)
0d8a4589	349	{
dd2b6810	350	AliVAODParticle* p = GetParticle(i);
0d8a4589	351	Double_t eta = p->Eta();
	352	if ( (eta < etamin) \|\| (eta > etamax) ) continue;
	353	if (p->Charge() != 0.0) n++;
	354	}
29e00d75	355	return n;
0d8a4589	356	}
	357	/**************************************************************************/
	358
	359	void AliAOD::Move(Double_t x, Double_t y, Double_t z)
	360	{
	361	//moves all spacial coordinates about this vector
	362	// vertex
	363	// track points
	364	// and whatever will be added to AOD and AOD particles that is a space coordinate
	365
	366	fPrimaryVertexX += x;
	367	fPrimaryVertexY += y;
	368	fPrimaryVertexZ += z;
	369
dd2b6810	370	Int_t npart = GetNumberOfParticles();
0d8a4589	371	for (Int_t i = 0; i < npart; i++)
0d8a4589	372	{
dd2b6810	373	AliVAODParticle* p = GetParticle(i);
0d8a4589	374	AliTrackPoints* tp = p->GetTPCTrackPoints();
	375	if (tp) tp->Move(x,y,z);
	376	tp = p->GetITSTrackPoints();
	377	if (tp) tp->Move(x,y,z);
	378	}
	379	}
d9122a01	380	/**************************************************************************/
dd2b6810	381
201c7e13	382	void AliAOD::Print(const Option_t* /option/) const
dd2b6810	383	{
	384	//Prints AOD
	385	TString ts;
	386	TString msg("\n");
	387	msg+="Particle Class: ";
	388	if (fParticleClass)
	389	{
	390	msg+=fParticleClass->GetName();
	391	}
	392	else
	393	{
	394	msg+="Not specified yet";
	395	}
	396	msg += "\n";
	397	msg += "Vertex position X: ";
	398	msg += fPrimaryVertexX;
	399	msg += " Y:" ;
	400	msg += fPrimaryVertexY;
	401	msg += " Z:";
	402	msg += fPrimaryVertexZ;
	403	msg += "\n";
	404
	405	msg += "Randomized: ";
	406	msg += fIsRandomized;
	407	msg += "\n";
	408
	409	Info("Print","%s",msg.Data());
	410
	411	Int_t npart = GetNumberOfParticles();
	412	Info("Print","Npart: %d",npart);
	413	for (Int_t i = 0; i < npart; i++)
	414	{
	415	Info("Print","Getting particle %d",i);
	416	AliVAODParticle* p = GetParticle(i);
	417	Info("Print","Printing particle %d, address %#x",i,p);
	418	p->Dump();
	419	p->Print();
	420	Info("Print","particle %d printed",i);
	421	}
	422	}
	423
	424	void AliAOD::SetOwner(Bool_t /owner/)
	425	{
	426	//Sets the ownership of particles: if particles should be also deleted if AOD is deleted/reseted
	427	//Since fParticles is Clones and not Object Array, it is always the owner and this method does not have sense
	428
	429	MayNotUse("SetOwner");
	430	//if fParticles->SetOwner(owner);
	431
	432	}