[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"
#include "AliEventplane.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),
  fEP(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),
  fEP(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;
  fEP=ev.fEP;

  // 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),
  fEP(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;
  fEP=ev.fEP;
  // 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;
  fEP=aEvent.fEP;
  if (fTrackCollection) {
    for (AliFemtoTrackIterator iter=fTrackCollection->begin();iter!=fTrackCollection->end();iter++){
      delete *iter;
    }
    fTrackCollection->clear();
    delete fTrackCollection;
  }
  fTrackCollection = new AliFemtoTrackCollection;

  if (fV0Collection) {
    for (AliFemtoV0Iterator tV0iter=fV0Collection->begin();tV0iter!=fV0Collection->end();tV0iter++){
      delete *tV0iter;
    }//added by M Chojnacki To avodid memory leak 
    fV0Collection->clear();
    delete fV0Collection;
  }

  fV0Collection = new AliFemtoV0Collection;

  if (fXiCollection) {
    for (AliFemtoXiIterator tXiIter=fXiCollection->begin();tXiIter!=fXiCollection->end();tXiIter++){
      delete *tXiIter;
    }
    fXiCollection->clear();
    delete fXiCollection;
  }
  fXiCollection = new AliFemtoXiCollection;
  
  if (fKinkCollection) {
    for (AliFemtoKinkIterator kinkIter=fKinkCollection->begin();kinkIter!=fKinkCollection->end();kinkIter++){
      delete *kinkIter;
    }
    fKinkCollection->clear();
    delete fKinkCollection;
  }
  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; }
void AliFemtoEvent::SetEP(AliEventplane* ep) { fEP = ep;}
AliEventplane* AliFemtoEvent::EP() const {return fEP; }

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