[u/mrichter/AliRoot.git] / PWG2 / FEMTOSCOPY / AliFemto / AliFemtoEvent.cxx

///////////////////////////////////////////////////////////////////////////
//                                                                       //
//  AliFemtoEvent: hold the information specific to the event and a      //
//  track list                                                           //
//  AliFemtoEvent is the "transient microDST"  Objects of this class are //
//   generated from the input data by a Reader, and then presented to	 //
//   the Cuts of the various active Analyses.				 //
//                                                                       //
///////////////////////////////////////////////////////////////////////////
#include "AliFemtoEvent.h"
#include "AliFemtoTrack.h"
#include "AliFemtoV0.h"
#include "AliFemtoXi.h"
#include "AliFemtoKink.h"
#include "AliFemtoTrackCut.h"
#include "AliFemtoV0Cut.h"
#include "AliFemtoXiCut.h"
#include "AliFemtoKinkCut.h"
#include "PhysicalConstants.h"
#include "SystemOfUnits.h"

// Mike removed all of the AliFemtoTTree stuff here 21apr2006 - it was not used for a long time.


//___________________
AliFemtoEvent::AliFemtoEvent():
  fEventNumber(0),
  fRunNumber(0),
  fNumberOfTracks(0),
  fNormalizedMult(-2),
  fSPDMult(0),
  fEstimateITSTPC(0),
  fEstimateTracklets(0),
  fEstimateITSPure(0),
  fCentralityV0(0),
  fCentralityFMD(0),
  fCentralitySPD1(0),
  fCentralityTrk(0),
  fMagneticField(0),
  fIsCollisionCandidate(kTRUE),
  fPrimVertPos(0,0,0),
  fPrimVertCov(),
  fTrackCollection(0),
  fV0Collection(0),
  fXiCollection(0),
  fKinkCollection(0),
  fZDCN1Energy(0),   
  fZDCP1Energy(0),   
  fZDCN2Energy(0),   
  fZDCP2Energy(0),   
  fZDCEMEnergy(0),   
  fZDCParticipants(0),
  fTriggerMask(0),  
  fTriggerCluster(0),
  fReactionPlaneAngle(0)
{
  // Default constructor
  fPrimVertPos[0]=-999.0;
  fPrimVertPos[1]=-999.0;
  fPrimVertPos[2]=-999.0;
  fPrimVertCov[0]=0.000000000001;
  fPrimVertCov[1]=0.000000000001;
  fPrimVertCov[2]=0.000000000001;
  fPrimVertCov[3]=0.000000000001;
  fPrimVertCov[4]=0.000000000001;
  fPrimVertCov[5]=0.000000000001;
  fTrackCollection = new AliFemtoTrackCollection;
  fV0Collection = new AliFemtoV0Collection;
  fXiCollection = new AliFemtoXiCollection;
  fKinkCollection = new AliFemtoKinkCollection;
  fMagneticField=0.0;
}
//___________________
AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoXiCut* xCut, AliFemtoKinkCut* kCut):
  fEventNumber(0),
  fRunNumber(0),
  fNumberOfTracks(0),
  fNormalizedMult(-2),
  fSPDMult(0),
  fEstimateITSTPC(0),
  fEstimateTracklets(0),
  fEstimateITSPure(0),
  fCentralityV0(0),
  fCentralityFMD(0),
  fCentralitySPD1(0),
  fCentralityTrk(0),
  fMagneticField(0),
  fIsCollisionCandidate(kTRUE),
  fPrimVertPos(0,0,0),
  fPrimVertCov(),
  fTrackCollection(0),
  fV0Collection(0),
  fXiCollection(0),
  fKinkCollection(0),
  fZDCN1Energy(0),   
  fZDCP1Energy(0),   
  fZDCN2Energy(0),   
  fZDCP2Energy(0),   
  fZDCEMEnergy(0),   
  fZDCParticipants(0),
  fTriggerMask(0),  
  fTriggerCluster(0),
  fReactionPlaneAngle(0)
{ // copy constructor with track and v0 cuts
  //cout << "AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoV0Cut* kCut)" << endl;
  fEventNumber = ev.fEventNumber;
  fRunNumber = ev.fRunNumber;
  
  SetPrimVertCov(ev.PrimVertCov());

  fZDCN1Energy=ev.fZDCN1Energy;     
  fZDCP1Energy=ev.fZDCP1Energy;      
  fZDCN2Energy=ev.fZDCN2Energy;      
  fZDCP2Energy=ev.fZDCP2Energy;      
  fZDCEMEnergy=ev.fZDCEMEnergy;
  fZDCParticipants=ev.fZDCParticipants;
  fNumberOfTracks = ev.fNumberOfTracks;
  fNormalizedMult = ev.fNormalizedMult;
  fEstimateITSTPC = ev.fEstimateITSTPC;
  fEstimateTracklets = ev.fEstimateTracklets;
  fEstimateITSPure = ev.fEstimateITSPure;
  fCentralityV0 = ev.fCentralityV0; 
  fCentralityFMD = ev.fCentralityFMD;
  fCentralitySPD1 = ev.fCentralitySPD1;
  fCentralityTrk = ev.fCentralityTrk;
  fMagneticField= ev.fMagneticField;
  fIsCollisionCandidate = ev.fIsCollisionCandidate;

  fTriggerMask=ev.fTriggerMask;     // Trigger Type (mask)
  fTriggerCluster=ev.fTriggerCluster;
  fReactionPlaneAngle=ev.fReactionPlaneAngle;

  // create collections
  fTrackCollection = new AliFemtoTrackCollection;
  fV0Collection = new AliFemtoV0Collection;
  fXiCollection = new AliFemtoXiCollection;
  fKinkCollection = new AliFemtoKinkCollection;
  // copy track collection  
  for ( AliFemtoTrackIterator tIter=ev.fTrackCollection->begin(); tIter!=ev.fTrackCollection->end(); tIter++) {
    if ( !tCut || tCut->Pass(*tIter) ) {
      AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
      fTrackCollection->push_back(trackCopy);
    }
  }
  // copy v0 collection
  for ( AliFemtoV0Iterator vIter=ev.fV0Collection->begin(); vIter!=ev.fV0Collection->end(); vIter++) {
    if ( !vCut || vCut->Pass(*vIter) ) {
      AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
      fV0Collection->push_back(v0Copy);
    }
  }
  // copy xi collection
  for ( AliFemtoXiIterator xIter=ev.fXiCollection->begin(); xIter!=ev.fXiCollection->end(); xIter++) {
    if ( !xCut || xCut->Pass(*xIter) ) {
      AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
      fXiCollection->push_back(xiCopy);
    }
  }
  // copy kink collection  
  for ( AliFemtoKinkIterator kIter=ev.fKinkCollection->begin(); kIter!=ev.fKinkCollection->end(); kIter++) {
    if ( !kCut || kCut->Pass(*kIter) ) {
      //cout << " kinkCut passed " << endl;
      AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
      fKinkCollection->push_back(kinkCopy);
    }
  }
}
//___________________
AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev):
  fEventNumber(0),
  fRunNumber(0),
  fNumberOfTracks(0),
  fNormalizedMult(-2),
  fSPDMult(0),
  fEstimateITSTPC(0),
  fEstimateTracklets(0),
  fEstimateITSPure(0),
  fCentralityV0(0),
  fCentralityFMD(0),
  fCentralitySPD1(0),
  fCentralityTrk(0),
  fMagneticField(0),
  fIsCollisionCandidate(kTRUE),
  fPrimVertPos(0,0,0),
  fPrimVertCov(),
  fTrackCollection(0),
  fV0Collection(0),
  fXiCollection(0),
  fKinkCollection(0),
  fZDCN1Energy(0),   
  fZDCP1Energy(0),   
  fZDCN2Energy(0),   
  fZDCP2Energy(0),   
  fZDCEMEnergy(0),   
  fZDCParticipants(0),
  fTriggerMask(0),  
  fTriggerCluster(0),
  fReactionPlaneAngle(0)
{ 
  // copy constructor 
  fEventNumber = ev.fEventNumber;
  fRunNumber = ev.fRunNumber;
  
  SetPrimVertCov(ev.PrimVertCov());

  fZDCN1Energy=ev.fZDCN1Energy;     
  fZDCP1Energy=ev.fZDCP1Energy;      
  fZDCN2Energy=ev.fZDCN2Energy;      
  fZDCP2Energy=ev.fZDCP2Energy;      
  fZDCEMEnergy=ev.fZDCEMEnergy;
  fZDCParticipants=ev.fZDCParticipants;
  fNumberOfTracks = ev.fNumberOfTracks;
  fEstimateITSTPC = ev.fEstimateITSTPC;
  fEstimateTracklets = ev.fEstimateTracklets;
  fEstimateITSPure = ev.fEstimateITSPure;
  fCentralityV0 = ev.fCentralityV0; 
  fCentralityFMD = ev.fCentralityFMD;
  fCentralitySPD1 = ev.fCentralitySPD1;
  fCentralityTrk = ev.fCentralityTrk;
  fMagneticField= ev.fMagneticField;
  fIsCollisionCandidate = ev.fIsCollisionCandidate;
  fTriggerMask=ev.fTriggerMask;     // Trigger Type (mask)
  fTriggerCluster=ev.fTriggerCluster;
  fReactionPlaneAngle=ev.fReactionPlaneAngle;
  // create collections
  fTrackCollection = new AliFemtoTrackCollection;
  fV0Collection = new AliFemtoV0Collection;
  fXiCollection = new AliFemtoXiCollection;
  fKinkCollection = new AliFemtoKinkCollection;
  // copy track collection  
  for ( AliFemtoTrackIterator tIter=ev.fTrackCollection->begin(); tIter!=ev.fTrackCollection->end(); tIter++) {
    AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
    fTrackCollection->push_back(trackCopy);
  }
  // copy v0 collection
  for ( AliFemtoV0Iterator vIter=ev.fV0Collection->begin(); vIter!=ev.fV0Collection->end(); vIter++) {
    AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
    fV0Collection->push_back(v0Copy);
  }
  // copy xi collection
  for ( AliFemtoXiIterator xIter=ev.fXiCollection->begin(); xIter!=ev.fXiCollection->end(); xIter++) {
    AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
    fXiCollection->push_back(xiCopy);
  }
  // copy kink collection  
  for ( AliFemtoKinkIterator kIter=ev.fKinkCollection->begin(); kIter!=ev.fKinkCollection->end(); kIter++) {
    //cout << " kinkCut passed " << endl;
    AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
    fKinkCollection->push_back(kinkCopy);
  }
}
//______________________________
AliFemtoEvent& AliFemtoEvent::operator=(const AliFemtoEvent& aEvent)
{
  // assignment operator
  if (this == &aEvent)
    return *this;

  fEventNumber = aEvent.fEventNumber;
  fRunNumber = aEvent.fRunNumber;
  
  fZDCN1Energy=aEvent.fZDCN1Energy;     
  fZDCP1Energy=aEvent.fZDCP1Energy;      
  fZDCN2Energy=aEvent.fZDCN2Energy;      
  fZDCP2Energy=aEvent.fZDCP2Energy;      
  fZDCEMEnergy=aEvent.fZDCEMEnergy;
  fZDCParticipants=aEvent.fZDCParticipants;
  fNumberOfTracks = aEvent.fNumberOfTracks;
  fEstimateITSTPC = aEvent.fEstimateITSTPC;
  fEstimateTracklets = aEvent.fEstimateTracklets;
  fEstimateITSPure = aEvent.fEstimateITSPure;
  fCentralityV0 = aEvent.fCentralityV0; 
  fCentralityFMD = aEvent.fCentralityFMD;
  fCentralitySPD1 = aEvent.fCentralitySPD1;
  fCentralityTrk = aEvent.fCentralityTrk;
  fNormalizedMult = aEvent.fNormalizedMult;
  fEstimateITSTPC = aEvent.fEstimateITSTPC;
  fEstimateTracklets = aEvent.fEstimateTracklets;
  fEstimateITSPure = aEvent.fEstimateITSPure;
  fMagneticField= aEvent.fMagneticField;
  fIsCollisionCandidate = aEvent.fIsCollisionCandidate;

  fTriggerMask=aEvent.fTriggerMask;     // Trigger Type (mask)
  fTriggerCluster=aEvent.fTriggerCluster;
  fReactionPlaneAngle=aEvent.fReactionPlaneAngle;
  // create collections
  fTrackCollection = new AliFemtoTrackCollection;
  fV0Collection = new AliFemtoV0Collection;
  fXiCollection = new AliFemtoXiCollection;
  fKinkCollection = new AliFemtoKinkCollection;
  // copy track collection  
  for ( AliFemtoTrackIterator tIter=aEvent.fTrackCollection->begin(); tIter!=aEvent.fTrackCollection->end(); tIter++) {
    AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
    fTrackCollection->push_back(trackCopy);
  }
  // copy v0 collection
  for ( AliFemtoV0Iterator vIter=aEvent.fV0Collection->begin(); vIter!=aEvent.fV0Collection->end(); vIter++) {
    AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
    fV0Collection->push_back(v0Copy);
  }
  // copy xi collection
  for ( AliFemtoXiIterator xIter=aEvent.fXiCollection->begin(); xIter!=aEvent.fXiCollection->end(); xIter++) {
    AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
    fXiCollection->push_back(xiCopy);
  }
  // copy kink collection  
  for ( AliFemtoKinkIterator kIter=aEvent.fKinkCollection->begin(); kIter!=aEvent.fKinkCollection->end(); kIter++) {
    AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
    fKinkCollection->push_back(kinkCopy);
  }

  return *this;
}

//___________________
AliFemtoEvent::~AliFemtoEvent(){
  // destructor
#ifdef STHBTDEBUG
  cout << " AliFemtoEvent::~AliFemtoEvent() " << endl;
#endif
  for (AliFemtoTrackIterator iter=fTrackCollection->begin();iter!=fTrackCollection->end();iter++){
    delete *iter;
  }
  fTrackCollection->clear();
  delete fTrackCollection;
  //must do the same for the V0 collection
  for (AliFemtoV0Iterator tV0iter=fV0Collection->begin();tV0iter!=fV0Collection->end();tV0iter++){
    delete *tV0iter;
  }//added by M Chojnacki To avodid memory leak 
  fV0Collection->clear();
  delete fV0Collection;
  //must do the same for the Xi collection
  for (AliFemtoXiIterator tXiIter=fXiCollection->begin();tXiIter!=fXiCollection->end();tXiIter++){
    delete *tXiIter;
  }
  fXiCollection->clear();
  delete fXiCollection;
  //must do the same for the Kink collection
  for (AliFemtoKinkIterator kinkIter=fKinkCollection->begin();kinkIter!=fKinkCollection->end();kinkIter++){
    delete *kinkIter;
  }
  fKinkCollection->clear();
  delete fKinkCollection;
}
//___________________


void AliFemtoEvent::SetEventNumber(const unsigned short& event){fEventNumber = event;}
void AliFemtoEvent::SetRunNumber(const int& runNum){fRunNumber = runNum;}


void AliFemtoEvent::SetZDCN1Energy(const float& aZDCN1Energy){fZDCN1Energy=aZDCN1Energy;}
void AliFemtoEvent::SetZDCP1Energy(const float& aZDCP1Energy){fZDCP1Energy=aZDCP1Energy;}      
void AliFemtoEvent::SetZDCN2Energy(const float& aZDCN2Energy){fZDCN2Energy=aZDCN2Energy;}      
void AliFemtoEvent::SetZDCP2Energy(const float& aZDCP2Energy){fZDCP2Energy=aZDCP2Energy;}      
void AliFemtoEvent::SetZDCEMEnergy(const float& aZDCEMEnergy){fZDCEMEnergy=aZDCEMEnergy;}    
void AliFemtoEvent::SetZDCParticipants(const unsigned int& aZDCParticipants){fZDCParticipants=aZDCParticipants;}

void AliFemtoEvent::SetNumberOfTracks(const unsigned short& tracks){fNumberOfTracks = tracks;}
void AliFemtoEvent::SetNormalizedMult(const int& i){fNormalizedMult = i;}
void AliFemtoEvent::SetSPDMult(const int& i){fSPDMult = i;}

void AliFemtoEvent::SetPrimVertPos(const AliFemtoThreeVector& vp){fPrimVertPos = vp;}
void AliFemtoEvent::SetPrimVertCov(const double* v){
  fPrimVertCov[0] = v[0];
  fPrimVertCov[1] = v[1];
  fPrimVertCov[2] = v[2];
  fPrimVertCov[3] = v[3];
  fPrimVertCov[4] = v[4];
  fPrimVertCov[5] = v[5];
}
void AliFemtoEvent::SetMagneticField(const double& magF){fMagneticField = magF;}
void AliFemtoEvent::SetIsCollisionCandidate(const bool& is){fIsCollisionCandidate = is;}

void AliFemtoEvent::SetTriggerMask(const unsigned long int& aTriggerMask) {fTriggerMask=aTriggerMask;}
void AliFemtoEvent::SetTriggerCluster(const unsigned char& aTriggerCluster) {fTriggerCluster=aTriggerCluster;}


unsigned short AliFemtoEvent::EventNumber() const {return fEventNumber;}
int            AliFemtoEvent::RunNumber() const {return fRunNumber;}


unsigned short AliFemtoEvent::NumberOfTracks() const {return fNumberOfTracks;}

AliFemtoV0Collection* AliFemtoEvent::V0Collection() const {return fV0Collection;}
AliFemtoXiCollection* AliFemtoEvent::XiCollection() const {return fXiCollection;}
AliFemtoKinkCollection* AliFemtoEvent::KinkCollection() const {return fKinkCollection;}
AliFemtoTrackCollection* AliFemtoEvent::TrackCollection() const {return fTrackCollection;}
AliFemtoThreeVector AliFemtoEvent::PrimVertPos() const {return fPrimVertPos;}
const double* AliFemtoEvent::PrimVertCov() const {return fPrimVertCov;}
double AliFemtoEvent::MagneticField() const {return fMagneticField;}
unsigned long int AliFemtoEvent::TriggerMask() const {return fTriggerMask;}
unsigned char AliFemtoEvent::TriggerCluster() const {return fTriggerCluster;}
bool AliFemtoEvent::IsCollisionCandidate() const {return fIsCollisionCandidate;}


float AliFemtoEvent::ZDCN1Energy() const {return fZDCN1Energy;}       
float AliFemtoEvent::ZDCP1Energy() const {return fZDCP1Energy;}       
float AliFemtoEvent::ZDCN2Energy() const {return fZDCN2Energy;}       
float AliFemtoEvent::ZDCP2Energy() const {return fZDCP2Energy;}       
float AliFemtoEvent::ZDCEMEnergy() const {return fZDCEMEnergy;}   
unsigned int  AliFemtoEvent::ZDCParticipants() const {return fZDCParticipants;}

void AliFemtoEvent::SetReactionPlaneAngle(const float& a) { fReactionPlaneAngle = a;}
float AliFemtoEvent::ReactionPlaneAngle() const { return fReactionPlaneAngle; }

//----------------------------- below here is only for star

int AliFemtoEvent::UncorrectedNumberOfNegativePrimaries() const
{
  return NumberOfTracks()/2;
}

int AliFemtoEvent::SPDMultiplicity() const
{
  return fSPDMult;
}

int AliFemtoEvent::UncorrectedNumberOfPrimaries() const
{
  if (fNormalizedMult < -1) {
    // Count number of normalized charged tracks 
    Int_t tNormTrackCount = 0;
    for (AliFemtoTrackIterator iter=fTrackCollection->begin();iter!=fTrackCollection->end();iter++){
      if (!((*iter)->Flags()&(AliFemtoTrack::kTPCrefit))) continue;
      if ((*iter)->TPCncls() < 50) continue;
      if ((*iter)->TPCchi2()/(*iter)->TPCncls() > 60.0) continue;
      if ((*iter)->ImpactD() > 6.0) continue;
      if ((*iter)->ImpactZ() > 6.0) continue;
      if (fabs((*iter)->P().PseudoRapidity()) > 0.9) continue;
      
      tNormTrackCount++;
    }
    return tNormTrackCount;
  }

  return fNormalizedMult;
  //  return NumberOfTracks();
}

unsigned short AliFemtoEvent::MultiplicityEstimateITSTPC() const
{
  return fEstimateITSTPC;
}

unsigned short AliFemtoEvent::MultiplicityEstimateTracklets() const
{
  return fEstimateTracklets;
}

unsigned short AliFemtoEvent::MultiplicityEstimateITSPure() const
{
  return fEstimateITSPure;
}

void AliFemtoEvent::SetMultiplicityEstimateITSTPC(const unsigned short &s)
{
  fEstimateITSTPC = s;
}

void AliFemtoEvent::SetMultiplicityEstimateTracklets(const unsigned short &s)
{
  fEstimateTracklets = s;
}

void AliFemtoEvent::SetMultiplicityEstimateITSPure(const unsigned short &s)
{
  fEstimateITSPure = s;
}

void AliFemtoEvent::SetCentralityV0(const float &c)
{
  fCentralityV0 = c;
}

void AliFemtoEvent::SetCentralityFMD(const float &c)
{
  fCentralityFMD = c;
}

void AliFemtoEvent::SetCentralitySPD1(const float &c)
{
  fCentralitySPD1 = c;
}

void AliFemtoEvent::SetCentralityTrk(const float &c)
{
  fCentralityTrk = c;
}

float AliFemtoEvent::CentralityV0() const
{
  return fCentralityV0;
}

float AliFemtoEvent::CentralityFMD() const
{
  return fCentralityFMD;
}

float AliFemtoEvent::CentralitySPD1() const
{
  return fCentralitySPD1;
}

float AliFemtoEvent::CentralityTrk() const
{
  return fCentralityTrk;
}
Commit	Line	Data
d0e92d9a	1	///////////////////////////////////////////////////////////////////////////
	2	// //
	3	// AliFemtoEvent: hold the information specific to the event and a //
	4	// track list //
	5	// AliFemtoEvent is the "transient microDST" Objects of this class are //
	6	// generated from the input data by a Reader, and then presented to //
	7	// the Cuts of the various active Analyses. //
	8	// //
	9	///////////////////////////////////////////////////////////////////////////
	10	#include "AliFemtoEvent.h"
	11	#include "AliFemtoTrack.h"
	12	#include "AliFemtoV0.h"
	13	#include "AliFemtoXi.h"
	14	#include "AliFemtoKink.h"
	15	#include "AliFemtoTrackCut.h"
	16	#include "AliFemtoV0Cut.h"
	17	#include "AliFemtoXiCut.h"
	18	#include "AliFemtoKinkCut.h"
	19	#include "PhysicalConstants.h"
	20	#include "SystemOfUnits.h"
67427ff7	21
	22	// Mike removed all of the AliFemtoTTree stuff here 21apr2006 - it was not used for a long time.
	23
	24
	25
	26	//___________________
0215f606	27	AliFemtoEvent::AliFemtoEvent():
	28	fEventNumber(0),
	29	fRunNumber(0),
	30	fNumberOfTracks(0),
fe77f653	31	fNormalizedMult(-2),
e7186cc6	32	fSPDMult(0),
73c932f8	33	fEstimateITSTPC(0),
	34	fEstimateTracklets(0),
	35	fEstimateITSPure(0),
fe77f653	36	fCentralityV0(0),
	37	fCentralityFMD(0),
	38	fCentralitySPD1(0),
	39	fCentralityTrk(0),
0215f606	40	fMagneticField(0),
73695088	41	fIsCollisionCandidate(kTRUE),
0215f606	42	fPrimVertPos(0,0,0),
63a5982a	43	fPrimVertCov(),
0215f606	44	fTrackCollection(0),
	45	fV0Collection(0),
	46	fXiCollection(0),
	47	fKinkCollection(0),
	48	fZDCN1Energy(0),
	49	fZDCP1Energy(0),
	50	fZDCN2Energy(0),
	51	fZDCP2Energy(0),
	52	fZDCEMEnergy(0),
	53	fZDCParticipants(0),
	54	fTriggerMask(0),
683877d2	55	fTriggerCluster(0),
683877d2	56	fReactionPlaneAngle(0)
0215f606	57	{
d0e92d9a	58	// Default constructor
67427ff7	59	fPrimVertPos[0]=-999.0;
	60	fPrimVertPos[1]=-999.0;
	61	fPrimVertPos[2]=-999.0;
63a5982a	62	fPrimVertCov[0]=0.000000000001;
	63	fPrimVertCov[1]=0.000000000001;
	64	fPrimVertCov[2]=0.000000000001;
	65	fPrimVertCov[3]=0.000000000001;
	66	fPrimVertCov[4]=0.000000000001;
	67	fPrimVertCov[5]=0.000000000001;
67427ff7	68	fTrackCollection = new AliFemtoTrackCollection;
	69	fV0Collection = new AliFemtoV0Collection;
	70	fXiCollection = new AliFemtoXiCollection;
	71	fKinkCollection = new AliFemtoKinkCollection;
	72	fMagneticField=0.0;
	73	}
	74	//___________________
0215f606	75	AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoXiCut* xCut, AliFemtoKinkCut* kCut):
	76	fEventNumber(0),
	77	fRunNumber(0),
	78	fNumberOfTracks(0),
fe77f653	79	fNormalizedMult(-2),
e7186cc6	80	fSPDMult(0),
73c932f8	81	fEstimateITSTPC(0),
	82	fEstimateTracklets(0),
	83	fEstimateITSPure(0),
fe77f653	84	fCentralityV0(0),
	85	fCentralityFMD(0),
	86	fCentralitySPD1(0),
	87	fCentralityTrk(0),
0215f606	88	fMagneticField(0),
73695088	89	fIsCollisionCandidate(kTRUE),
0215f606	90	fPrimVertPos(0,0,0),
63a5982a	91	fPrimVertCov(),
0215f606	92	fTrackCollection(0),
	93	fV0Collection(0),
	94	fXiCollection(0),
	95	fKinkCollection(0),
	96	fZDCN1Energy(0),
	97	fZDCP1Energy(0),
	98	fZDCN2Energy(0),
	99	fZDCP2Energy(0),
	100	fZDCEMEnergy(0),
	101	fZDCParticipants(0),
	102	fTriggerMask(0),
683877d2	103	fTriggerCluster(0),
683877d2	104	fReactionPlaneAngle(0)
0215f606	105	{ // copy constructor with track and v0 cuts
67427ff7	106	//cout << "AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev, AliFemtoTrackCut* tCut, AliFemtoV0Cut* vCut, AliFemtoV0Cut* kCut)" << endl;
	107	fEventNumber = ev.fEventNumber;
	108	fRunNumber = ev.fRunNumber;
	109
63a5982a	110	SetPrimVertCov(ev.PrimVertCov());
63a5982a	111
67427ff7	112	fZDCN1Energy=ev.fZDCN1Energy;
	113	fZDCP1Energy=ev.fZDCP1Energy;
	114	fZDCN2Energy=ev.fZDCN2Energy;
	115	fZDCP2Energy=ev.fZDCP2Energy;
	116	fZDCEMEnergy=ev.fZDCEMEnergy;
	117	fZDCParticipants=ev.fZDCParticipants;
	118	fNumberOfTracks = ev.fNumberOfTracks;
03decc29	119	fNormalizedMult = ev.fNormalizedMult;
73c932f8	120	fEstimateITSTPC = ev.fEstimateITSTPC;
	121	fEstimateTracklets = ev.fEstimateTracklets;
	122	fEstimateITSPure = ev.fEstimateITSPure;
fe77f653	123	fCentralityV0 = ev.fCentralityV0;
	124	fCentralityFMD = ev.fCentralityFMD;
	125	fCentralitySPD1 = ev.fCentralitySPD1;
	126	fCentralityTrk = ev.fCentralityTrk;
67427ff7	127	fMagneticField= ev.fMagneticField;
73695088	128	fIsCollisionCandidate = ev.fIsCollisionCandidate;
73695088	129
67427ff7	130	fTriggerMask=ev.fTriggerMask; // Trigger Type (mask)
67427ff7	131	fTriggerCluster=ev.fTriggerCluster;
683877d2	132	fReactionPlaneAngle=ev.fReactionPlaneAngle;
683877d2	133
67427ff7	134	// create collections
	135	fTrackCollection = new AliFemtoTrackCollection;
	136	fV0Collection = new AliFemtoV0Collection;
	137	fXiCollection = new AliFemtoXiCollection;
	138	fKinkCollection = new AliFemtoKinkCollection;
	139	// copy track collection
	140	for ( AliFemtoTrackIterator tIter=ev.fTrackCollection->begin(); tIter!=ev.fTrackCollection->end(); tIter++) {
	141	if ( !tCut \|\| tCut->Pass(*tIter) ) {
	142	AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
	143	fTrackCollection->push_back(trackCopy);
	144	}
	145	}
	146	// copy v0 collection
	147	for ( AliFemtoV0Iterator vIter=ev.fV0Collection->begin(); vIter!=ev.fV0Collection->end(); vIter++) {
	148	if ( !vCut \|\| vCut->Pass(*vIter) ) {
	149	AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
	150	fV0Collection->push_back(v0Copy);
	151	}
	152	}
	153	// copy xi collection
	154	for ( AliFemtoXiIterator xIter=ev.fXiCollection->begin(); xIter!=ev.fXiCollection->end(); xIter++) {
	155	if ( !xCut \|\| xCut->Pass(*xIter) ) {
	156	AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
	157	fXiCollection->push_back(xiCopy);
	158	}
	159	}
	160	// copy kink collection
	161	for ( AliFemtoKinkIterator kIter=ev.fKinkCollection->begin(); kIter!=ev.fKinkCollection->end(); kIter++) {
	162	if ( !kCut \|\| kCut->Pass(*kIter) ) {
	163	//cout << " kinkCut passed " << endl;
	164	AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
	165	fKinkCollection->push_back(kinkCopy);
	166	}
	167	}
	168	}
ea77036b	169	//___________________
	170	AliFemtoEvent::AliFemtoEvent(const AliFemtoEvent& ev):
	171	fEventNumber(0),
	172	fRunNumber(0),
	173	fNumberOfTracks(0),
fe77f653	174	fNormalizedMult(-2),
e7186cc6	175	fSPDMult(0),
73c932f8	176	fEstimateITSTPC(0),
	177	fEstimateTracklets(0),
	178	fEstimateITSPure(0),
fe77f653	179	fCentralityV0(0),
	180	fCentralityFMD(0),
	181	fCentralitySPD1(0),
	182	fCentralityTrk(0),
ea77036b	183	fMagneticField(0),
73695088	184	fIsCollisionCandidate(kTRUE),
ea77036b	185	fPrimVertPos(0,0,0),
63a5982a	186	fPrimVertCov(),
ea77036b	187	fTrackCollection(0),
	188	fV0Collection(0),
	189	fXiCollection(0),
	190	fKinkCollection(0),
	191	fZDCN1Energy(0),
	192	fZDCP1Energy(0),
	193	fZDCN2Energy(0),
	194	fZDCP2Energy(0),
	195	fZDCEMEnergy(0),
	196	fZDCParticipants(0),
	197	fTriggerMask(0),
683877d2	198	fTriggerCluster(0),
683877d2	199	fReactionPlaneAngle(0)
ea77036b	200	{
	201	// copy constructor
	202	fEventNumber = ev.fEventNumber;
	203	fRunNumber = ev.fRunNumber;
	204
63a5982a	205	SetPrimVertCov(ev.PrimVertCov());
63a5982a	206
ea77036b	207	fZDCN1Energy=ev.fZDCN1Energy;
	208	fZDCP1Energy=ev.fZDCP1Energy;
	209	fZDCN2Energy=ev.fZDCN2Energy;
	210	fZDCP2Energy=ev.fZDCP2Energy;
	211	fZDCEMEnergy=ev.fZDCEMEnergy;
	212	fZDCParticipants=ev.fZDCParticipants;
	213	fNumberOfTracks = ev.fNumberOfTracks;
73c932f8	214	fEstimateITSTPC = ev.fEstimateITSTPC;
	215	fEstimateTracklets = ev.fEstimateTracklets;
	216	fEstimateITSPure = ev.fEstimateITSPure;
fe77f653	217	fCentralityV0 = ev.fCentralityV0;
	218	fCentralityFMD = ev.fCentralityFMD;
	219	fCentralitySPD1 = ev.fCentralitySPD1;
	220	fCentralityTrk = ev.fCentralityTrk;
ea77036b	221	fMagneticField= ev.fMagneticField;
73695088	222	fIsCollisionCandidate = ev.fIsCollisionCandidate;
ea77036b	223	fTriggerMask=ev.fTriggerMask; // Trigger Type (mask)
ea77036b	224	fTriggerCluster=ev.fTriggerCluster;
683877d2	225	fReactionPlaneAngle=ev.fReactionPlaneAngle;
ea77036b	226	// create collections
	227	fTrackCollection = new AliFemtoTrackCollection;
	228	fV0Collection = new AliFemtoV0Collection;
	229	fXiCollection = new AliFemtoXiCollection;
	230	fKinkCollection = new AliFemtoKinkCollection;
	231	// copy track collection
	232	for ( AliFemtoTrackIterator tIter=ev.fTrackCollection->begin(); tIter!=ev.fTrackCollection->end(); tIter++) {
	233	AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
	234	fTrackCollection->push_back(trackCopy);
	235	}
	236	// copy v0 collection
	237	for ( AliFemtoV0Iterator vIter=ev.fV0Collection->begin(); vIter!=ev.fV0Collection->end(); vIter++) {
	238	AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
	239	fV0Collection->push_back(v0Copy);
	240	}
	241	// copy xi collection
	242	for ( AliFemtoXiIterator xIter=ev.fXiCollection->begin(); xIter!=ev.fXiCollection->end(); xIter++) {
	243	AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
	244	fXiCollection->push_back(xiCopy);
	245	}
	246	// copy kink collection
	247	for ( AliFemtoKinkIterator kIter=ev.fKinkCollection->begin(); kIter!=ev.fKinkCollection->end(); kIter++) {
	248	//cout << " kinkCut passed " << endl;
	249	AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
	250	fKinkCollection->push_back(kinkCopy);
	251	}
	252	}
0215f606	253	//______________________________
	254	AliFemtoEvent& AliFemtoEvent::operator=(const AliFemtoEvent& aEvent)
	255	{
d0e92d9a	256	// assignment operator
0215f606	257	if (this == &aEvent)
	258	return *this;
	259
	260	fEventNumber = aEvent.fEventNumber;
	261	fRunNumber = aEvent.fRunNumber;
	262
	263	fZDCN1Energy=aEvent.fZDCN1Energy;
	264	fZDCP1Energy=aEvent.fZDCP1Energy;
	265	fZDCN2Energy=aEvent.fZDCN2Energy;
	266	fZDCP2Energy=aEvent.fZDCP2Energy;
	267	fZDCEMEnergy=aEvent.fZDCEMEnergy;
	268	fZDCParticipants=aEvent.fZDCParticipants;
	269	fNumberOfTracks = aEvent.fNumberOfTracks;
73c932f8	270	fEstimateITSTPC = aEvent.fEstimateITSTPC;
	271	fEstimateTracklets = aEvent.fEstimateTracklets;
	272	fEstimateITSPure = aEvent.fEstimateITSPure;
fe77f653	273	fCentralityV0 = aEvent.fCentralityV0;
	274	fCentralityFMD = aEvent.fCentralityFMD;
	275	fCentralitySPD1 = aEvent.fCentralitySPD1;
	276	fCentralityTrk = aEvent.fCentralityTrk;
03decc29	277	fNormalizedMult = aEvent.fNormalizedMult;
73c932f8	278	fEstimateITSTPC = aEvent.fEstimateITSTPC;
	279	fEstimateTracklets = aEvent.fEstimateTracklets;
	280	fEstimateITSPure = aEvent.fEstimateITSPure;
0215f606	281	fMagneticField= aEvent.fMagneticField;
73695088	282	fIsCollisionCandidate = aEvent.fIsCollisionCandidate;
73695088	283
0215f606	284	fTriggerMask=aEvent.fTriggerMask; // Trigger Type (mask)
0215f606	285	fTriggerCluster=aEvent.fTriggerCluster;
683877d2	286	fReactionPlaneAngle=aEvent.fReactionPlaneAngle;
0215f606	287	// create collections
	288	fTrackCollection = new AliFemtoTrackCollection;
	289	fV0Collection = new AliFemtoV0Collection;
	290	fXiCollection = new AliFemtoXiCollection;
	291	fKinkCollection = new AliFemtoKinkCollection;
	292	// copy track collection
	293	for ( AliFemtoTrackIterator tIter=aEvent.fTrackCollection->begin(); tIter!=aEvent.fTrackCollection->end(); tIter++) {
	294	AliFemtoTrack* trackCopy = new AliFemtoTrack(**tIter);
	295	fTrackCollection->push_back(trackCopy);
	296	}
	297	// copy v0 collection
	298	for ( AliFemtoV0Iterator vIter=aEvent.fV0Collection->begin(); vIter!=aEvent.fV0Collection->end(); vIter++) {
	299	AliFemtoV0* v0Copy = new AliFemtoV0(**vIter);
	300	fV0Collection->push_back(v0Copy);
	301	}
	302	// copy xi collection
	303	for ( AliFemtoXiIterator xIter=aEvent.fXiCollection->begin(); xIter!=aEvent.fXiCollection->end(); xIter++) {
	304	AliFemtoXi* xiCopy = new AliFemtoXi(**xIter);
	305	fXiCollection->push_back(xiCopy);
	306	}
	307	// copy kink collection
	308	for ( AliFemtoKinkIterator kIter=aEvent.fKinkCollection->begin(); kIter!=aEvent.fKinkCollection->end(); kIter++) {
	309	AliFemtoKink* kinkCopy = new AliFemtoKink(**kIter);
	310	fKinkCollection->push_back(kinkCopy);
	311	}
	312
	313	return *this;
	314	}
	315
67427ff7	316	//___________________
67427ff7	317	AliFemtoEvent::~AliFemtoEvent(){
d0e92d9a	318	// destructor
67427ff7	319	#ifdef STHBTDEBUG
	320	cout << " AliFemtoEvent::~AliFemtoEvent() " << endl;
	321	#endif
	322	for (AliFemtoTrackIterator iter=fTrackCollection->begin();iter!=fTrackCollection->end();iter++){
	323	delete *iter;
	324	}
	325	fTrackCollection->clear();
	326	delete fTrackCollection;
	327	//must do the same for the V0 collection
d0e92d9a	328	for (AliFemtoV0Iterator tV0iter=fV0Collection->begin();tV0iter!=fV0Collection->end();tV0iter++){
d0e92d9a	329	delete *tV0iter;
67427ff7	330	}//added by M Chojnacki To avodid memory leak
	331	fV0Collection->clear();
	332	delete fV0Collection;
	333	//must do the same for the Xi collection
d0e92d9a	334	for (AliFemtoXiIterator tXiIter=fXiCollection->begin();tXiIter!=fXiCollection->end();tXiIter++){
d0e92d9a	335	delete *tXiIter;
67427ff7	336	}
	337	fXiCollection->clear();
	338	delete fXiCollection;
	339	//must do the same for the Kink collection
	340	for (AliFemtoKinkIterator kinkIter=fKinkCollection->begin();kinkIter!=fKinkCollection->end();kinkIter++){
	341	delete *kinkIter;
	342	}
	343	fKinkCollection->clear();
	344	delete fKinkCollection;
	345	}
	346	//___________________
	347
	348
	349
	350	void AliFemtoEvent::SetEventNumber(const unsigned short& event){fEventNumber = event;}
	351	void AliFemtoEvent::SetRunNumber(const int& runNum){fRunNumber = runNum;}
	352
	353
9064872d	354	void AliFemtoEvent::SetZDCN1Energy(const float& aZDCN1Energy){fZDCN1Energy=aZDCN1Energy;}
	355	void AliFemtoEvent::SetZDCP1Energy(const float& aZDCP1Energy){fZDCP1Energy=aZDCP1Energy;}
	356	void AliFemtoEvent::SetZDCN2Energy(const float& aZDCN2Energy){fZDCN2Energy=aZDCN2Energy;}
	357	void AliFemtoEvent::SetZDCP2Energy(const float& aZDCP2Energy){fZDCP2Energy=aZDCP2Energy;}
	358	void AliFemtoEvent::SetZDCEMEnergy(const float& aZDCEMEnergy){fZDCEMEnergy=aZDCEMEnergy;}
	359	void AliFemtoEvent::SetZDCParticipants(const unsigned int& aZDCParticipants){fZDCParticipants=aZDCParticipants;}
67427ff7	360
67427ff7	361	void AliFemtoEvent::SetNumberOfTracks(const unsigned short& tracks){fNumberOfTracks = tracks;}
03decc29	362	void AliFemtoEvent::SetNormalizedMult(const int& i){fNormalizedMult = i;}
e2b7a66d	363	void AliFemtoEvent::SetSPDMult(const int& i){fSPDMult = i;}
67427ff7	364
67427ff7	365	void AliFemtoEvent::SetPrimVertPos(const AliFemtoThreeVector& vp){fPrimVertPos = vp;}
63a5982a	366	void AliFemtoEvent::SetPrimVertCov(const double* v){
	367	fPrimVertCov[0] = v[0];
	368	fPrimVertCov[1] = v[1];
	369	fPrimVertCov[2] = v[2];
	370	fPrimVertCov[3] = v[3];
	371	fPrimVertCov[4] = v[4];
	372	fPrimVertCov[5] = v[5];
	373	}
67427ff7	374	void AliFemtoEvent::SetMagneticField(const double& magF){fMagneticField = magF;}
73695088	375	void AliFemtoEvent::SetIsCollisionCandidate(const bool& is){fIsCollisionCandidate = is;}
67427ff7	376
9064872d	377	void AliFemtoEvent::SetTriggerMask(const unsigned long int& aTriggerMask) {fTriggerMask=aTriggerMask;}
9064872d	378	void AliFemtoEvent::SetTriggerCluster(const unsigned char& aTriggerCluster) {fTriggerCluster=aTriggerCluster;}
67427ff7	379
	380
	381	unsigned short AliFemtoEvent::EventNumber() const {return fEventNumber;}
	382	int AliFemtoEvent::RunNumber() const {return fRunNumber;}
	383
	384
	385
	386	unsigned short AliFemtoEvent::NumberOfTracks() const {return fNumberOfTracks;}
	387
	388	AliFemtoV0Collection* AliFemtoEvent::V0Collection() const {return fV0Collection;}
	389	AliFemtoXiCollection* AliFemtoEvent::XiCollection() const {return fXiCollection;}
	390	AliFemtoKinkCollection* AliFemtoEvent::KinkCollection() const {return fKinkCollection;}
	391	AliFemtoTrackCollection* AliFemtoEvent::TrackCollection() const {return fTrackCollection;}
	392	AliFemtoThreeVector AliFemtoEvent::PrimVertPos() const {return fPrimVertPos;}
63a5982a	393	const double* AliFemtoEvent::PrimVertCov() const {return fPrimVertCov;}
67427ff7	394	double AliFemtoEvent::MagneticField() const {return fMagneticField;}
	395	unsigned long int AliFemtoEvent::TriggerMask() const {return fTriggerMask;}
	396	unsigned char AliFemtoEvent::TriggerCluster() const {return fTriggerCluster;}
73695088	397	bool AliFemtoEvent::IsCollisionCandidate() const {return fIsCollisionCandidate;}
67427ff7	398
	399
	400	float AliFemtoEvent::ZDCN1Energy() const {return fZDCN1Energy;}
	401	float AliFemtoEvent::ZDCP1Energy() const {return fZDCP1Energy;}
	402	float AliFemtoEvent::ZDCN2Energy() const {return fZDCN2Energy;}
	403	float AliFemtoEvent::ZDCP2Energy() const {return fZDCP2Energy;}
	404	float AliFemtoEvent::ZDCEMEnergy() const {return fZDCEMEnergy;}
	405	unsigned int AliFemtoEvent::ZDCParticipants() const {return fZDCParticipants;}
	406
683877d2	407	void AliFemtoEvent::SetReactionPlaneAngle(const float& a) { fReactionPlaneAngle = a;}
	408	float AliFemtoEvent::ReactionPlaneAngle() const { return fReactionPlaneAngle; }
	409
67427ff7	410	//----------------------------- below here is only for star
67427ff7	411
fe77f653	412	int AliFemtoEvent::UncorrectedNumberOfNegativePrimaries() const
67427ff7	413	{
	414	return NumberOfTracks()/2;
	415	}
	416
fe77f653	417	int AliFemtoEvent::SPDMultiplicity() const
e2b7a66d	418	{
	419	return fSPDMult;
	420	}
	421
fe77f653	422	int AliFemtoEvent::UncorrectedNumberOfPrimaries() const
67427ff7	423	{
fe77f653	424	if (fNormalizedMult < -1) {
03decc29	425	// Count number of normalized charged tracks
	426	Int_t tNormTrackCount = 0;
	427	for (AliFemtoTrackIterator iter=fTrackCollection->begin();iter!=fTrackCollection->end();iter++){
	428	if (!((*iter)->Flags()&(AliFemtoTrack::kTPCrefit))) continue;
	429	if ((*iter)->TPCncls() < 50) continue;
	430	if ((iter)->TPCchi2()/(iter)->TPCncls() > 60.0) continue;
	431	if ((*iter)->ImpactD() > 6.0) continue;
	432	if ((*iter)->ImpactZ() > 6.0) continue;
69c1c8ff	433	if (fabs((*iter)->P().PseudoRapidity()) > 0.9) continue;
03decc29	434
	435	tNormTrackCount++;
	436	}
	437	return tNormTrackCount;
73695088	438	}
73695088	439
03decc29	440	return fNormalizedMult;
73695088	441	// return NumberOfTracks();
67427ff7	442	}
e7186cc6	443
73c932f8	444	unsigned short AliFemtoEvent::MultiplicityEstimateITSTPC() const
	445	{
	446	return fEstimateITSTPC;
	447	}
	448
	449	unsigned short AliFemtoEvent::MultiplicityEstimateTracklets() const
	450	{
	451	return fEstimateTracklets;
	452	}
	453
	454	unsigned short AliFemtoEvent::MultiplicityEstimateITSPure() const
	455	{
	456	return fEstimateITSPure;
	457	}
	458
	459	void AliFemtoEvent::SetMultiplicityEstimateITSTPC(const unsigned short &s)
	460	{
	461	fEstimateITSTPC = s;
	462	}
	463
	464	void AliFemtoEvent::SetMultiplicityEstimateTracklets(const unsigned short &s)
	465	{
	466	fEstimateTracklets = s;
	467	}
	468
	469	void AliFemtoEvent::SetMultiplicityEstimateITSPure(const unsigned short &s)
	470	{
	471	fEstimateITSPure = s;
	472	}
fe77f653	473
	474	void AliFemtoEvent::SetCentralityV0(const float &c)
	475	{
	476	fCentralityV0 = c;
	477	}
	478
	479	void AliFemtoEvent::SetCentralityFMD(const float &c)
	480	{
	481	fCentralityFMD = c;
	482	}
	483
	484	void AliFemtoEvent::SetCentralitySPD1(const float &c)
	485	{
	486	fCentralitySPD1 = c;
	487	}
	488
	489	void AliFemtoEvent::SetCentralityTrk(const float &c)
	490	{
	491	fCentralityTrk = c;
	492	}
	493
	494	float AliFemtoEvent::CentralityV0() const
	495	{
	496	return fCentralityV0;
	497	}
	498
	499	float AliFemtoEvent::CentralityFMD() const
	500	{
	501	return fCentralityFMD;
	502	}
	503
	504	float AliFemtoEvent::CentralitySPD1() const
	505	{
	506	return fCentralitySPD1;
	507	}
	508
	509	float AliFemtoEvent::CentralityTrk() const
	510	{
	511	return fCentralityTrk;
	512	}