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

////////////////////////////////////////////////////////////////////////////////
///                                                                          ///
/// AliFemtoEventReaderESDChain - the reader class for the Alice ESD         ///
/// tailored for the Task framework                                 ///
/// Reads in AliESDfriend to create shared hit/quality information           ///
/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu                           ///
///                                                                          ///
////////////////////////////////////////////////////////////////////////////////
#include "AliFemtoEventReaderESDChain.h"

#include "TFile.h"
#include "TTree.h"
#include "AliESDEvent.h"
#include "AliESDtrack.h"
#include "AliESDVertex.h"

#include "AliFmPhysicalHelixD.h"
#include "AliFmThreeVectorF.h"

#include "SystemOfUnits.h"

#include "AliFemtoEvent.h"

ClassImp(AliFemtoEventReaderESDChain)

#if !(ST_NO_NAMESPACES)
  using namespace units;
#endif

using namespace std;
//____________________________
AliFemtoEventReaderESDChain::AliFemtoEventReaderESDChain():
  fFileName(" "),
  fConstrained(true),
  fNumberofEvent(0),
  fCurEvent(0),
  fCurFile(0),
  fEvent(0x0)
{
  //constructor with 0 parameters , look at default settings 
//   fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fClusterPerPadrow[tPad] = new list<Int_t>();
//   }
//   fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fSharedList[tPad] = new list<Int_t>();
//   }
}

//__________________
AliFemtoEventReaderESDChain::AliFemtoEventReaderESDChain(const AliFemtoEventReaderESDChain& aReader):
  fFileName(" "),
  fConstrained(true),
  fNumberofEvent(0),
  fCurEvent(0),
  fCurFile(0),
  fEvent(0x0)
{
  // Copy constructor
  fConstrained = aReader.fConstrained;
  fNumberofEvent = aReader.fNumberofEvent;
  fCurEvent = aReader.fCurEvent;
  fCurFile = aReader.fCurFile;
  //  fEvent = new AliESD(*aReader.fEvent);
  fEvent = new AliESDEvent();
//   fEventFriend = aReader.fEventFriend;
//   fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fClusterPerPadrow[tPad] = new list<Int_t>();
//     list<Int_t>::iterator iter;
//     for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
//       fClusterPerPadrow[tPad]->push_back(*iter);
//     }
//   }
//   fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fSharedList[tPad] = new list<Int_t>();
//     list<Int_t>::iterator iter;
//     for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
//       fSharedList[tPad]->push_back(*iter);
//     }
//   }
}
//__________________
AliFemtoEventReaderESDChain::~AliFemtoEventReaderESDChain()
{
  //Destructor
  delete fEvent;

//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fClusterPerPadrow[tPad]->clear();
//     delete fClusterPerPadrow[tPad];
//   }
//   delete [] fClusterPerPadrow;
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fSharedList[tPad]->clear();
//     delete fSharedList[tPad];
//   }
//   delete [] fSharedList;
}

//__________________
AliFemtoEventReaderESDChain& AliFemtoEventReaderESDChain::operator=(const AliFemtoEventReaderESDChain& aReader)
{
  // Assignment operator
  if (this == &aReader)
    return *this;

  fConstrained = aReader.fConstrained;
  fNumberofEvent = aReader.fNumberofEvent;
  fCurEvent = aReader.fCurEvent;
  fCurFile = aReader.fCurFile;
  if (fEvent) delete fEvent;
  fEvent = new AliESDEvent();

  //  fEventFriend = aReader.fEventFriend;
  
//   if (fClusterPerPadrow) {
//     for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//       fClusterPerPadrow[tPad]->clear();
//       delete fClusterPerPadrow[tPad];
//     }
//     delete [] fClusterPerPadrow;
//   }
  
//   if (fSharedList) {
//     for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//       fSharedList[tPad]->clear();
//       delete fSharedList[tPad];
//     }
//     delete [] fSharedList;
//   }

//   fClusterPerPadrow = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fClusterPerPadrow[tPad] = new list<Int_t>();
//     list<Int_t>::iterator iter;
//     for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
//       fClusterPerPadrow[tPad]->push_back(*iter);
//     }
//   }
//   fSharedList = (list<Int_t> **) malloc(sizeof(list<Int_t> *) * AliESDfriendTrack::kMaxTPCcluster);
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fSharedList[tPad] = new list<Int_t>();
//     list<Int_t>::iterator iter;
//     for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
//       fSharedList[tPad]->push_back(*iter);
//     }
//   }
  
  return *this;
}
//__________________
// Simple report
AliFemtoString AliFemtoEventReaderESDChain::Report()
{
  AliFemtoString temp = "\n This is the AliFemtoEventReaderESDChain\n";
  return temp;
}

//__________________
void AliFemtoEventReaderESDChain::SetConstrained(const bool constrained)
{
  // Select whether to read constrained or not constrained momentum
  fConstrained=constrained;
}
//__________________
bool AliFemtoEventReaderESDChain::GetConstrained() const
{
  // Check whether we read constrained or not constrained momentum
  return fConstrained;
}
//__________________
AliFemtoEvent* AliFemtoEventReaderESDChain::ReturnHbtEvent()
{
  // Get the event, read all the relevant information
  // and fill the AliFemtoEvent class
  // Returns a valid AliFemtoEvent
  AliFemtoEvent *hbtEvent = 0;
  string tFriendFileName;

  // Get the friend information
  cout<<"starting to read event "<<fCurEvent<<endl;
  //  fEvent->SetESDfriend(fEventFriend);
  vector<int> tLabelTable;//to check labels
	
  hbtEvent = new AliFemtoEvent;
  //setting basic things
  //  hbtEvent->SetEventNumber(fEvent->GetEventNumber());
  hbtEvent->SetRunNumber(fEvent->GetRunNumber());
  //hbtEvent->SetNumberOfTracks(fEvent->GetNumberOfTracks());
  hbtEvent->SetMagneticField(fEvent->GetMagneticField()*kilogauss);//to check if here is ok
  hbtEvent->SetZDCN1Energy(fEvent->GetZDCN1Energy());
  hbtEvent->SetZDCP1Energy(fEvent->GetZDCP1Energy());
  hbtEvent->SetZDCN2Energy(fEvent->GetZDCN2Energy());
  hbtEvent->SetZDCP2Energy(fEvent->GetZDCP2Energy());
  hbtEvent->SetZDCEMEnergy(fEvent->GetZDCEMEnergy());
  hbtEvent->SetZDCParticipants(fEvent->GetZDCParticipants());
  hbtEvent->SetTriggerMask(fEvent->GetTriggerMask());
  hbtEvent->SetTriggerCluster(fEvent->GetTriggerCluster());
	
  //Vertex
  double fV1[3];
  fEvent->GetVertex()->GetXYZ(fV1);

  AliFmThreeVectorF vertex(fV1[0],fV1[1],fV1[2]);
  hbtEvent->SetPrimVertPos(vertex);
	
  //starting to reading tracks
  int nofTracks=0;  //number of reconstructed tracks in event
  nofTracks=fEvent->GetNumberOfTracks();
  int realnofTracks=0;//number of track which we use ina analysis

//   // Clear the shared cluster list
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fClusterPerPadrow[tPad]->clear();
//   }
//   for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
//     fSharedList[tPad]->clear();
//   }


//   for (int i=0;i<nofTracks;i++) {
//     const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track

//     list<Int_t>::iterator tClustIter;

//     Int_t tTrackIndices[AliESDfriendTrack::kMaxTPCcluster];
//     Int_t tNClusters = esdtrack->GetTPCclusters(tTrackIndices);
//     for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
//       if (tTrackIndices[tNcl] >= 0) {
// 	tClustIter = find(fClusterPerPadrow[tNcl]->begin(), fClusterPerPadrow[tNcl]->end(), tTrackIndices[tNcl]);
// 	if (tClustIter == fClusterPerPadrow[tNcl]->end()) {
// 	  fClusterPerPadrow[tNcl]->push_back(tTrackIndices[tNcl]);
// 	}
// 	else {
// 	  fSharedList[tNcl]->push_back(tTrackIndices[tNcl]);
// 	}
//       }
//     }
      
//   }

  for (int i=0;i<nofTracks;i++)
    {
      bool  tGoodMomentum=true; //flaga to chcek if we can read momentum of this track
		
      AliFemtoTrack* trackCopy = new AliFemtoTrack();	
      const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track
      //      const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();

      trackCopy->SetCharge((short)esdtrack->GetSign());

      //in aliroot we have AliPID 
      //0-electron 1-muon 2-pion 3-kaon 4-proton 5-photon 6-pi0 7-neutron 8-kaon0 9-eleCon   
      //we use only 5 first
      double esdpid[5];
      esdtrack->GetESDpid(esdpid);
      trackCopy->SetPidProbElectron(esdpid[0]);
      trackCopy->SetPidProbMuon(esdpid[1]);
      trackCopy->SetPidProbPion(esdpid[2]);
      trackCopy->SetPidProbKaon(esdpid[3]);
      trackCopy->SetPidProbProton(esdpid[4]);
						
      double pxyz[3];
      if (fConstrained==true)		    
	tGoodMomentum=esdtrack->GetConstrainedPxPyPz(pxyz); //reading constrained momentum
      else
	tGoodMomentum=esdtrack->GetPxPyPz(pxyz);//reading noconstarined momentum

      AliFemtoThreeVector v(pxyz[0],pxyz[1],pxyz[2]);
      if (v.mag() == 0) {
	//	cout << "Found 0 momentum ???? " <<endl;
	delete trackCopy;
	continue;
      }
      trackCopy->SetP(v);//setting momentum
      trackCopy->SetPt(sqrt(pxyz[0]*pxyz[0]+pxyz[1]*pxyz[1]));
      const AliFmThreeVectorD kP(pxyz[0],pxyz[1],pxyz[2]);
      const AliFmThreeVectorD kOrigin(fV1[0],fV1[1],fV1[2]);
      //setting helix I do not if it is ok
      AliFmPhysicalHelixD helix(kP,kOrigin,(double)(fEvent->GetMagneticField())*kilogauss,(double)(trackCopy->Charge())); 
      trackCopy->SetHelix(helix);
	    	
      trackCopy->SetTrackId(esdtrack->GetID());
      trackCopy->SetFlags(esdtrack->GetStatus());
      //trackCopy->SetLabel(esdtrack->GetLabel());
		
      //some stuff which could be useful 
      float impact[2];
      float covimpact[3];
      esdtrack->GetImpactParameters(impact,covimpact);
      trackCopy->SetImpactD(impact[0]);
      trackCopy->SetImpactZ(impact[1]);
      trackCopy->SetCdd(covimpact[0]);
      trackCopy->SetCdz(covimpact[1]);
      trackCopy->SetCzz(covimpact[2]);
      trackCopy->SetITSchi2(esdtrack->GetITSchi2());    
      trackCopy->SetITSncls(esdtrack->GetNcls(0));     
      trackCopy->SetTPCchi2(esdtrack->GetTPCchi2());       
      trackCopy->SetTPCncls(esdtrack->GetTPCNcls());       
      trackCopy->SetTPCnclsF(esdtrack->GetTPCNclsF());      
      trackCopy->SetTPCsignalN((short)esdtrack->GetTPCsignalN()); //due to bug in aliesdtrack class   
      trackCopy->SetTPCsignalS(esdtrack->GetTPCsignalSigma()); 

//       // Fill cluster per padrow information
//       Int_t tTrackIndices[AliESDfriendTrack::kMaxTPCcluster];
//       Int_t tNClusters = esdtrack->GetTPCclusters(tTrackIndices);
//       for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
// 	if (tTrackIndices[tNcl] > 0)
// 	  trackCopy->SetTPCcluster(tNcl, 1);
// 	else
// 	  trackCopy->SetTPCcluster(tNcl, 0);
//       }
      
//       // Fill shared cluster information
//       list<Int_t>::iterator tClustIter;

//       for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
// 	if (tTrackIndices[tNcl] > 0) {
// 	  tClustIter = find(fSharedList[tNcl]->begin(), fSharedList[tNcl]->end(), tTrackIndices[tNcl]);
// 	  if (tClustIter != fSharedList[tNcl]->end()) {
// 	    trackCopy->SetTPCshared(tNcl, 1);
// 	    cout << "Event next" <<  endl;
// 	    cout << "Track: " << i << endl;
// 	    cout << "Shared cluster: " << tNcl << " " << tTrackIndices[tNcl] << endl;
// 	  }
// 	  else {
// 	    trackCopy->SetTPCshared(tNcl, 0);
// 	  }
// 	}
//       }

      trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap());
      trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap());

      if (tGoodMomentum==true)
	{
	  hbtEvent->TrackCollection()->push_back(trackCopy);//adding track to analysis
	  realnofTracks++;//real number of tracks
	  //	  delete trackCopy;
	}
      else
	{
	  delete  trackCopy;
	}
		
    }

  hbtEvent->SetNumberOfTracks(realnofTracks);//setting number of track which we read in event	
  fCurEvent++;	
  cout<<"end of reading nt "<<nofTracks<<" real number "<<realnofTracks<<endl;
  return hbtEvent; 
}
//___________________
void AliFemtoEventReaderESDChain::SetESDSource(AliESDEvent *aESD)
{
  // The chain loads the ESD for us
  // You must provide the address where it can be found
  fEvent = aESD;
}
//___________________
// void AliFemtoEventReaderESDChain::SetESDfriendSource(AliESDfriend *aFriend)
// {
//   // We need the ESD tree to obtain
//   // information about the friend file location
//   fEventFriend = aFriend;
// }
Commit	Line	Data
d0e92d9a	1	////////////////////////////////////////////////////////////////////////////////
	2	/// ///
	3	/// AliFemtoEventReaderESDChain - the reader class for the Alice ESD ///
	4	/// tailored for the Task framework ///
	5	/// Reads in AliESDfriend to create shared hit/quality information ///
	6	/// Authors: Adam Kisiel kisiel@mps.ohio-state.edu ///
	7	/// ///
	8	////////////////////////////////////////////////////////////////////////////////
67427ff7	9	#include "AliFemtoEventReaderESDChain.h"
	10
	11	#include "TFile.h"
	12	#include "TTree.h"
ea77036b	13	#include "AliESDEvent.h"
67427ff7	14	#include "AliESDtrack.h"
ea77036b	15	#include "AliESDVertex.h"
67427ff7	16
d0e92d9a	17	#include "AliFmPhysicalHelixD.h"
d0e92d9a	18	#include "AliFmThreeVectorF.h"
67427ff7	19
d0e92d9a	20	#include "SystemOfUnits.h"
67427ff7	21
d0e92d9a	22	#include "AliFemtoEvent.h"
67427ff7	23
	24	ClassImp(AliFemtoEventReaderESDChain)
	25
	26	#if !(ST_NO_NAMESPACES)
	27	using namespace units;
	28	#endif
	29
	30	using namespace std;
	31	//____________________________
67427ff7	32	AliFemtoEventReaderESDChain::AliFemtoEventReaderESDChain():
	33	fFileName(" "),
	34	fConstrained(true),
	35	fNumberofEvent(0),
	36	fCurEvent(0),
	37	fCurFile(0),
ea77036b	38	fEvent(0x0)
67427ff7	39	{
d0e92d9a	40	//constructor with 0 parameters , look at default settings
ea77036b	41	// fClusterPerPadrow = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	42	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	43	// fClusterPerPadrow[tPad] = new list<Int_t>();
	44	// }
	45	// fSharedList = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	46	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	47	// fSharedList[tPad] = new list<Int_t>();
	48	// }
67427ff7	49	}
67427ff7	50
0215f606	51	//__________________
0215f606	52	AliFemtoEventReaderESDChain::AliFemtoEventReaderESDChain(const AliFemtoEventReaderESDChain& aReader):
	53	fFileName(" "),
	54	fConstrained(true),
	55	fNumberofEvent(0),
	56	fCurEvent(0),
	57	fCurFile(0),
ea77036b	58	fEvent(0x0)
0215f606	59	{
d0e92d9a	60	// Copy constructor
0215f606	61	fConstrained = aReader.fConstrained;
	62	fNumberofEvent = aReader.fNumberofEvent;
	63	fCurEvent = aReader.fCurEvent;
	64	fCurFile = aReader.fCurFile;
d0e92d9a	65	// fEvent = new AliESD(*aReader.fEvent);
ea77036b	66	fEvent = new AliESDEvent();
	67	// fEventFriend = aReader.fEventFriend;
	68	// fClusterPerPadrow = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	69	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	70	// fClusterPerPadrow[tPad] = new list<Int_t>();
	71	// list<Int_t>::iterator iter;
	72	// for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
	73	// fClusterPerPadrow[tPad]->push_back(*iter);
	74	// }
	75	// }
	76	// fSharedList = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	77	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	78	// fSharedList[tPad] = new list<Int_t>();
	79	// list<Int_t>::iterator iter;
	80	// for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
	81	// fSharedList[tPad]->push_back(*iter);
	82	// }
	83	// }
0215f606	84	}
67427ff7	85	//__________________
67427ff7	86	AliFemtoEventReaderESDChain::~AliFemtoEventReaderESDChain()
67427ff7	87	{
d0e92d9a	88	//Destructor
67427ff7	89	delete fEvent;
67427ff7	90
ea77036b	91	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	92	// fClusterPerPadrow[tPad]->clear();
	93	// delete fClusterPerPadrow[tPad];
	94	// }
	95	// delete [] fClusterPerPadrow;
	96	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	97	// fSharedList[tPad]->clear();
	98	// delete fSharedList[tPad];
	99	// }
	100	// delete [] fSharedList;
67427ff7	101	}
67427ff7	102
0215f606	103	//__________________
0215f606	104	AliFemtoEventReaderESDChain& AliFemtoEventReaderESDChain::operator=(const AliFemtoEventReaderESDChain& aReader)
0215f606	105	{
d0e92d9a	106	// Assignment operator
0215f606	107	if (this == &aReader)
	108	return *this;
	109
	110	fConstrained = aReader.fConstrained;
	111	fNumberofEvent = aReader.fNumberofEvent;
	112	fCurEvent = aReader.fCurEvent;
	113	fCurFile = aReader.fCurFile;
	114	if (fEvent) delete fEvent;
ea77036b	115	fEvent = new AliESDEvent();
0215f606	116
ea77036b	117	// fEventFriend = aReader.fEventFriend;
0215f606	118
ea77036b	119	// if (fClusterPerPadrow) {
	120	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	121	// fClusterPerPadrow[tPad]->clear();
	122	// delete fClusterPerPadrow[tPad];
	123	// }
	124	// delete [] fClusterPerPadrow;
	125	// }
0215f606	126
ea77036b	127	// if (fSharedList) {
	128	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	129	// fSharedList[tPad]->clear();
	130	// delete fSharedList[tPad];
	131	// }
	132	// delete [] fSharedList;
	133	// }
	134
	135	// fClusterPerPadrow = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	136	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	137	// fClusterPerPadrow[tPad] = new list<Int_t>();
	138	// list<Int_t>::iterator iter;
	139	// for (iter=aReader.fClusterPerPadrow[tPad]->begin(); iter!=aReader.fClusterPerPadrow[tPad]->end(); iter++) {
	140	// fClusterPerPadrow[tPad]->push_back(*iter);
	141	// }
	142	// }
	143	// fSharedList = (list<Int_t> *) malloc(sizeof(list<Int_t> ) * AliESDfriendTrack::kMaxTPCcluster);
	144	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	145	// fSharedList[tPad] = new list<Int_t>();
	146	// list<Int_t>::iterator iter;
	147	// for (iter=aReader.fSharedList[tPad]->begin(); iter!=aReader.fSharedList[tPad]->end(); iter++) {
	148	// fSharedList[tPad]->push_back(*iter);
	149	// }
	150	// }
0215f606	151
	152	return *this;
	153	}
67427ff7	154	//__________________
	155	// Simple report
	156	AliFemtoString AliFemtoEventReaderESDChain::Report()
	157	{
	158	AliFemtoString temp = "\n This is the AliFemtoEventReaderESDChain\n";
	159	return temp;
	160	}
	161
	162	//__________________
67427ff7	163	void AliFemtoEventReaderESDChain::SetConstrained(const bool constrained)
67427ff7	164	{
d0e92d9a	165	// Select whether to read constrained or not constrained momentum
67427ff7	166	fConstrained=constrained;
	167	}
	168	//__________________
67427ff7	169	bool AliFemtoEventReaderESDChain::GetConstrained() const
67427ff7	170	{
d0e92d9a	171	// Check whether we read constrained or not constrained momentum
67427ff7	172	return fConstrained;
	173	}
	174	//__________________
	175	AliFemtoEvent* AliFemtoEventReaderESDChain::ReturnHbtEvent()
	176	{
	177	// Get the event, read all the relevant information
	178	// and fill the AliFemtoEvent class
	179	// Returns a valid AliFemtoEvent
	180	AliFemtoEvent *hbtEvent = 0;
	181	string tFriendFileName;
	182
	183	// Get the friend information
	184	cout<<"starting to read event "<<fCurEvent<<endl;
ea77036b	185	// fEvent->SetESDfriend(fEventFriend);
d0e92d9a	186	vector<int> tLabelTable;//to check labels
67427ff7	187
	188	hbtEvent = new AliFemtoEvent;
	189	//setting basic things
a531c6fc	190	// hbtEvent->SetEventNumber(fEvent->GetEventNumber());
67427ff7	191	hbtEvent->SetRunNumber(fEvent->GetRunNumber());
	192	//hbtEvent->SetNumberOfTracks(fEvent->GetNumberOfTracks());
	193	hbtEvent->SetMagneticField(fEvent->GetMagneticField()*kilogauss);//to check if here is ok
	194	hbtEvent->SetZDCN1Energy(fEvent->GetZDCN1Energy());
	195	hbtEvent->SetZDCP1Energy(fEvent->GetZDCP1Energy());
	196	hbtEvent->SetZDCN2Energy(fEvent->GetZDCN2Energy());
	197	hbtEvent->SetZDCP2Energy(fEvent->GetZDCP2Energy());
	198	hbtEvent->SetZDCEMEnergy(fEvent->GetZDCEMEnergy());
	199	hbtEvent->SetZDCParticipants(fEvent->GetZDCParticipants());
	200	hbtEvent->SetTriggerMask(fEvent->GetTriggerMask());
	201	hbtEvent->SetTriggerCluster(fEvent->GetTriggerCluster());
	202
	203	//Vertex
	204	double fV1[3];
	205	fEvent->GetVertex()->GetXYZ(fV1);
	206
	207	AliFmThreeVectorF vertex(fV1[0],fV1[1],fV1[2]);
	208	hbtEvent->SetPrimVertPos(vertex);
	209
	210	//starting to reading tracks
	211	int nofTracks=0; //number of reconstructed tracks in event
	212	nofTracks=fEvent->GetNumberOfTracks();
	213	int realnofTracks=0;//number of track which we use ina analysis
	214
ea77036b	215	// // Clear the shared cluster list
	216	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	217	// fClusterPerPadrow[tPad]->clear();
	218	// }
	219	// for (int tPad=0; tPad<AliESDfriendTrack::kMaxTPCcluster; tPad++) {
	220	// fSharedList[tPad]->clear();
	221	// }
	222
	223
	224	// for (int i=0;i<nofTracks;i++) {
	225	// const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track
	226
	227	// list<Int_t>::iterator tClustIter;
	228
	229	// Int_t tTrackIndices[AliESDfriendTrack::kMaxTPCcluster];
	230	// Int_t tNClusters = esdtrack->GetTPCclusters(tTrackIndices);
	231	// for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
	232	// if (tTrackIndices[tNcl] >= 0) {
	233	// tClustIter = find(fClusterPerPadrow[tNcl]->begin(), fClusterPerPadrow[tNcl]->end(), tTrackIndices[tNcl]);
	234	// if (tClustIter == fClusterPerPadrow[tNcl]->end()) {
	235	// fClusterPerPadrow[tNcl]->push_back(tTrackIndices[tNcl]);
	236	// }
	237	// else {
	238	// fSharedList[tNcl]->push_back(tTrackIndices[tNcl]);
	239	// }
	240	// }
	241	// }
67427ff7	242
ea77036b	243	// }
67427ff7	244
	245	for (int i=0;i<nofTracks;i++)
	246	{
d0e92d9a	247	bool tGoodMomentum=true; //flaga to chcek if we can read momentum of this track
67427ff7	248
	249	AliFemtoTrack* trackCopy = new AliFemtoTrack();
	250	const AliESDtrack *esdtrack=fEvent->GetTrack(i);//getting next track
0215f606	251	// const AliESDfriendTrack *tESDfriendTrack = esdtrack->GetFriendTrack();
67427ff7	252
	253	trackCopy->SetCharge((short)esdtrack->GetSign());
	254
	255	//in aliroot we have AliPID
	256	//0-electron 1-muon 2-pion 3-kaon 4-proton 5-photon 6-pi0 7-neutron 8-kaon0 9-eleCon
	257	//we use only 5 first
	258	double esdpid[5];
	259	esdtrack->GetESDpid(esdpid);
	260	trackCopy->SetPidProbElectron(esdpid[0]);
	261	trackCopy->SetPidProbMuon(esdpid[1]);
	262	trackCopy->SetPidProbPion(esdpid[2]);
	263	trackCopy->SetPidProbKaon(esdpid[3]);
	264	trackCopy->SetPidProbProton(esdpid[4]);
	265
	266	double pxyz[3];
	267	if (fConstrained==true)
d0e92d9a	268	tGoodMomentum=esdtrack->GetConstrainedPxPyPz(pxyz); //reading constrained momentum
67427ff7	269	else
d0e92d9a	270	tGoodMomentum=esdtrack->GetPxPyPz(pxyz);//reading noconstarined momentum
67427ff7	271
	272	AliFemtoThreeVector v(pxyz[0],pxyz[1],pxyz[2]);
	273	if (v.mag() == 0) {
	274	// cout << "Found 0 momentum ???? " <<endl;
	275	delete trackCopy;
	276	continue;
	277	}
	278	trackCopy->SetP(v);//setting momentum
	279	trackCopy->SetPt(sqrt(pxyz[0]pxyz[0]+pxyz[1]pxyz[1]));
d0e92d9a	280	const AliFmThreeVectorD kP(pxyz[0],pxyz[1],pxyz[2]);
d0e92d9a	281	const AliFmThreeVectorD kOrigin(fV1[0],fV1[1],fV1[2]);
67427ff7	282	//setting helix I do not if it is ok
d0e92d9a	283	AliFmPhysicalHelixD helix(kP,kOrigin,(double)(fEvent->GetMagneticField())*kilogauss,(double)(trackCopy->Charge()));
67427ff7	284	trackCopy->SetHelix(helix);
	285
	286	trackCopy->SetTrackId(esdtrack->GetID());
	287	trackCopy->SetFlags(esdtrack->GetStatus());
	288	//trackCopy->SetLabel(esdtrack->GetLabel());
	289
	290	//some stuff which could be useful
	291	float impact[2];
	292	float covimpact[3];
	293	esdtrack->GetImpactParameters(impact,covimpact);
	294	trackCopy->SetImpactD(impact[0]);
	295	trackCopy->SetImpactZ(impact[1]);
	296	trackCopy->SetCdd(covimpact[0]);
	297	trackCopy->SetCdz(covimpact[1]);
	298	trackCopy->SetCzz(covimpact[2]);
	299	trackCopy->SetITSchi2(esdtrack->GetITSchi2());
	300	trackCopy->SetITSncls(esdtrack->GetNcls(0));
	301	trackCopy->SetTPCchi2(esdtrack->GetTPCchi2());
	302	trackCopy->SetTPCncls(esdtrack->GetTPCNcls());
	303	trackCopy->SetTPCnclsF(esdtrack->GetTPCNclsF());
	304	trackCopy->SetTPCsignalN((short)esdtrack->GetTPCsignalN()); //due to bug in aliesdtrack class
	305	trackCopy->SetTPCsignalS(esdtrack->GetTPCsignalSigma());
	306
ea77036b	307	// // Fill cluster per padrow information
	308	// Int_t tTrackIndices[AliESDfriendTrack::kMaxTPCcluster];
	309	// Int_t tNClusters = esdtrack->GetTPCclusters(tTrackIndices);
	310	// for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
	311	// if (tTrackIndices[tNcl] > 0)
	312	// trackCopy->SetTPCcluster(tNcl, 1);
	313	// else
	314	// trackCopy->SetTPCcluster(tNcl, 0);
	315	// }
67427ff7	316
ea77036b	317	// // Fill shared cluster information
	318	// list<Int_t>::iterator tClustIter;
	319
	320	// for (int tNcl=0; tNcl<AliESDfriendTrack::kMaxTPCcluster; tNcl++) {
	321	// if (tTrackIndices[tNcl] > 0) {
	322	// tClustIter = find(fSharedList[tNcl]->begin(), fSharedList[tNcl]->end(), tTrackIndices[tNcl]);
	323	// if (tClustIter != fSharedList[tNcl]->end()) {
	324	// trackCopy->SetTPCshared(tNcl, 1);
	325	// cout << "Event next" << endl;
	326	// cout << "Track: " << i << endl;
	327	// cout << "Shared cluster: " << tNcl << " " << tTrackIndices[tNcl] << endl;
	328	// }
	329	// else {
	330	// trackCopy->SetTPCshared(tNcl, 0);
	331	// }
	332	// }
	333	// }
	334
	335	trackCopy->SetTPCClusterMap(esdtrack->GetTPCClusterMap());
	336	trackCopy->SetTPCSharedMap(esdtrack->GetTPCSharedMap());
67427ff7	337
d0e92d9a	338	if (tGoodMomentum==true)
67427ff7	339	{
	340	hbtEvent->TrackCollection()->push_back(trackCopy);//adding track to analysis
	341	realnofTracks++;//real number of tracks
	342	// delete trackCopy;
	343	}
	344	else
	345	{
	346	delete trackCopy;
	347	}
	348
	349	}
	350
	351	hbtEvent->SetNumberOfTracks(realnofTracks);//setting number of track which we read in event
	352	fCurEvent++;
	353	cout<<"end of reading nt "<<nofTracks<<" real number "<<realnofTracks<<endl;
	354	return hbtEvent;
	355	}
	356	//___________________
ea77036b	357	void AliFemtoEventReaderESDChain::SetESDSource(AliESDEvent *aESD)
67427ff7	358	{
d0e92d9a	359	// The chain loads the ESD for us
d0e92d9a	360	// You must provide the address where it can be found
67427ff7	361	fEvent = aESD;
	362	}
	363	//___________________
ea77036b	364	// void AliFemtoEventReaderESDChain::SetESDfriendSource(AliESDfriend *aFriend)
	365	// {
	366	// // We need the ESD tree to obtain
	367	// // information about the friend file location
	368	// fEventFriend = aFriend;
	369	// }
67427ff7	370
	371
	372
	373
	374
	375
	376
	377
	378