[u/mrichter/AliRoot.git] / JETAN / AliJetParticlesReaderESD.cxx

// $Id$

//____________________________________________________________________
//////////////////////////////////////////////////////////////////////
//                                                                  //
// class AliHBTReaderESD                                            //
//                                                                  //
// Reader for ALICE Event Summary Data (ESD).                       //
//                                                                  //
// Piotr.Skowronski@cern.ch                                         //
//                                                                  //
//////////////////////////////////////////////////////////////////////

#include <Riostream.h>
#include <TMath.h>
#include <TPDGCode.h>
#include <TString.h>
#include <TObjString.h>
#include <TTree.h>
#include <TFile.h>
#include <TKey.h>
#include <TH1.h>
#include <AliESD.h>
#include <AliESDtrack.h>
#include <AliKalmanTrack.h>
#include <AliJetEventParticles.h>
#include "AliJetParticlesReaderESD.h"

ClassImp(AliJetParticlesReaderESD)

AliJetParticlesReaderESD::AliJetParticlesReaderESD(Bool_t constrained,
						   const Char_t* esdfilename) :
  AliJetParticlesReader(),
  fConstrained(constrained),
  fESDFileName(esdfilename),
  fESD(0),
  fFile(0),
  fTree(0),
  fKeyIterator(0),
  fPassFlag(AliESDtrack::kTPCrefit)
{
  //constructor
}

/********************************************************************/
  
AliJetParticlesReaderESD::AliJetParticlesReaderESD(
                                      Bool_t constrained,
                                      TObjArray* dirs,
                                      const Char_t* esdfilename) :
  AliJetParticlesReader(dirs),
  fConstrained(constrained),
  fESDFileName(esdfilename),
  fESD(0),
  fFile(0),
  fTree(0),
  fKeyIterator(0),
  fPassFlag(AliESDtrack::kTPCrefit)
{
  //constructor
}

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

AliJetParticlesReaderESD::~AliJetParticlesReaderESD()
{
  //desctructor
  if(fESD) delete fESD;
  if(fTree) delete fTree;
  if(fKeyIterator) delete fKeyIterator;
  if(fFile) delete fFile;
}

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

Int_t AliJetParticlesReaderESD::ReadESD(AliESD* esd)
{
  //Reads one ESD

  if (esd == 0)
   {
     Error("ReadESD","ESD is NULL");
     return kFALSE;
   }

  //TDatabasePDG* pdgdb = TDatabasePDG::Instance();
  //if (pdgdb == 0)
  //{
  //   Error("ReadESD","Can not get PDG Database Instance.");
  //   return kFALSE;
  // }
   
  Float_t mf = esd->GetMagneticField(); 
  if (mf <= 0.0)  
  {
     Error("ReadESD","Magnetic Field is 0. Skipping to next event.");
     return kFALSE;
  }
  AliKalmanTrack::SetMagneticField(mf/10.);

  Info("ReadESD","Reading Event %d",fCurrentDir*1000+fCurrentEvent);
  if((!fOwner) || (fEventParticles==0)) 
    fEventParticles = new AliJetEventParticles();

  const Int_t kntr = esd->GetNumberOfTracks();
  Info("ReadESD","Found %d tracks.",kntr);
  fEventParticles->Reset(kntr);

  TString headdesc="";
  headdesc+="Run ";
  headdesc+=esd->GetRunNumber();
  headdesc+=": Ev ";
  headdesc+=esd->GetEventNumber();
  fEventParticles->SetHeader(headdesc);

  Double_t vertexpos[3];//vertex position
  const AliESDVertex* kvertex = esd->GetVertex();
  if (kvertex == 0)
   {
     Info("ReadESD","ESD returned NULL pointer to vertex - assuming (0.0,0.0,0.0)");
     vertexpos[0] = 0.0;
     vertexpos[1] = 0.0;
     vertexpos[2] = 0.0;
   }
  else
   {
     kvertex->GetXYZ(vertexpos);
   }
  fEventParticles->SetVertex(vertexpos[0],vertexpos[1],vertexpos[2]);

  //loop over tracks
  for (Int_t i = 0;i<kntr; i++)
   {

     const AliESDtrack *kesdtrack = esd->GetTrack(i);
     if (kesdtrack == 0)
      {
        Error("ReadESD","Can't get track %d", i);
        continue;
      }
     
     ULong_t cmptest=(kesdtrack->GetStatus() & fPassFlag);
     if (cmptest!=fPassFlag)
      {
	Info("ReadNext","Particle %d skipped: %u.",i,kesdtrack->GetStatus());
	cout << i << " "; PrintESDtrack(kesdtrack); cout << endl;
        continue;
      }

     Double_t mom[3];  //momentum
     Double_t xyz[3];  //position
     if (fConstrained) {
       if (kesdtrack->GetConstrainedChi2() > 25) continue;
       kesdtrack->GetConstrainedPxPyPz(mom);
       kesdtrack->GetConstrainedXYZ(xyz);
     } else {
       if(!kesdtrack->GetPxPyPzAt(0,mom)) continue;
       xyz[0]=0;xyz[1]=0;xyz[2]=0;
       //kesdtrack->GetPxPyPz(mom);
       //kesdtrack->GetXYZ(xyz);
     }
     const Float_t kmass=kesdtrack->GetMass();
     const Float_t kp2=mom[0]*mom[0]+mom[1]*mom[1]+mom[2]*mom[2];
     const Float_t ketot=TMath::Sqrt(kmass*kmass+kp2);
     const Float_t kpt=TMath::Sqrt(mom[0]*mom[0]+mom[1]*mom[1]);
     const Float_t kp=TMath::Sqrt(kp2);
     const Float_t keta=0.5*TMath::Log((kp+mom[2]+1e-30)/(kp-mom[2]+1e-30)); 
     const Float_t kphi=TMath::Pi()+TMath::ATan2(-mom[1],-mom[0]);
     //Double_t dx = xyz[0]-vertexpos[0];
     //Double_t dy = xyz[1]-vertexpos[1];
     //Float_t dca = TMath::Sqrt(dx*dx + dy*dy);
     //Float_t dz = xyz[2]-vertexpos[2];
     UInt_t index[6];
     const Int_t kncl=kesdtrack->GetITSclusters(index)
                      +kesdtrack->GetTPCclusters(NULL)
                      +kesdtrack->GetTRDclusters(NULL);
     if(IsAcceptedParticle(kpt,kphi,keta))
       fEventParticles->AddParticle(mom[0],mom[1],mom[2],ketot,i,kesdtrack->GetLabel(),kncl,kpt,kphi,keta);

   } // loop over tracks

  return kTRUE;
}

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

void AliJetParticlesReaderESD::Rewind()
{
  //rewinds reading 

  if(fFile) delete fFile;
  if(fKeyIterator) delete fKeyIterator;
  fKeyIterator = 0;
  fFile = 0;
  fCurrentDir = 0;
  fNEventsRead = 0;
}

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

Int_t AliJetParticlesReaderESD::ReadNext()
{
  //reads next event from fFile

  do   // is OK even if 0 dirs specified, 
    {  // in that case we try to read from "./"
      if (fFile == 0)
	{
	  fFile = OpenFile(fCurrentDir);
	  if (fFile == 0)
	    {
	      Error("ReadNext","Can't get fFile for dir no. %d",fCurrentDir);
	      fCurrentDir++;
	      continue;
	    }
     
	  fCurrentEvent = 0;
	  //fFile->GetListOfKeys()->Print();
	  
	  if(fTree) delete fTree;
	  fTree = dynamic_cast<TTree*>(fFile->Get("esdTree"));
	  if(fTree)
	    fTree->SetBranchAddress("ESD",&fESD);
	  else
	    fKeyIterator = new TIter(fFile->GetListOfKeys());  
	} 

      if(fTree)
	{
	  if(AliKalmanTrack::GetConvConst()<=0.)
	    AliKalmanTrack::SetMagneticField(0.5);
	  if(fCurrentEvent>=fTree->GetEntries())
	    {
	      fCurrentDir++;
	      delete fTree;
	      fTree = 0;
	      delete fFile;
	      fFile = 0;
	      continue;
	    }
	  fTree->GetEvent(fCurrentEvent);
	} 
      else 
	{ // "old" way via ESD objects stored in root file
	  TKey* key = (TKey*)fKeyIterator->Next();
	  if (key == 0)
	    {
	      fCurrentDir++;
	      delete fKeyIterator;
	      fKeyIterator = 0;
	      delete fFile; //we have to assume there are no more ESD objects in the fFile
	      fFile = 0;
	      continue;
	    }
	  TString esdname = "ESD";
	  esdname+=fCurrentEvent;
	  if(fESD) delete fESD;
	  fESD = dynamic_cast<AliESD*>(fFile->Get(esdname));
	  if (fESD == 0)
	    {
	      Info("ReadNext","Can't find AliESD object named %s",esdname.Data());
	      fCurrentDir++;
	      delete fKeyIterator;
	      fKeyIterator = 0;
	      delete fFile;//we have to assume there is no more ESD objects in the fFile
	      fFile = 0;
	      continue;
	    }
	}
      ReadESD(fESD);
      fCurrentEvent++;
      fNEventsRead++;
      return kTRUE;//success -> read one event
    }  while(fCurrentDir < GetNumberOfDirs());
      //end of loop over directories specified in fDirs Obj Array  
  return kFALSE; //no more directories to read
}

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

TFile* AliJetParticlesReaderESD::OpenFile(Int_t n)
{
  //opens fFile with kine tree

 const TString& dirname = GetDirName(n);
 if (dirname == "")
  {
   Error("OpenFiles","Can't get directory name");
   return 0;
  }
 TString filename = dirname +"/"+ fESDFileName;
 TFile *ret = TFile::Open(filename.Data()); 
 if (ret == 0)
  {
    Error("OpenFiles","Can't open fFile %s",filename.Data());
    return 0;
  }
 if (!ret->IsOpen())
  {
    Error("OpenFiles","Can't open fFile  %s",filename.Data());
    return 0;
  }
   
 return ret;
}

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

void AliJetParticlesReaderESD::PrintESDtrack(const AliESDtrack *kesdtrack) const
{
  ULong_t status=kesdtrack->GetStatus();
  cout << hex << status << dec << ": ";
  if((status & AliESDtrack::kITSin) == AliESDtrack::kITSin) cout << "ITSin ";
  if((status & AliESDtrack::kITSout) == AliESDtrack::kITSout) cout << "ITSout ";
  if((status & AliESDtrack::kITSrefit) == AliESDtrack::kITSrefit) cout << "ITSrefit ";
  if((status & AliESDtrack::kITSpid) == AliESDtrack::kITSpid) cout << "ITSpid ";

  if((status & AliESDtrack::kTPCin)  == AliESDtrack::kTPCin) cout << "TPCin ";
  if((status & AliESDtrack::kTPCout) == AliESDtrack::kTPCout) cout << "TPCout ";
  if((status & AliESDtrack::kTPCrefit) == AliESDtrack::kTPCrefit) cout << "TPCrefit ";
  if((status & AliESDtrack::kTPCpid) == AliESDtrack::kTPCpid) cout << "TPCpid ";

  if((status & AliESDtrack::kTRDin) == AliESDtrack::kTRDin) cout << "TRDin ";
  if((status & AliESDtrack::kTRDout) == AliESDtrack::kTRDout) cout << "TRDout ";
  if((status & AliESDtrack::kTRDrefit) == AliESDtrack::kTRDrefit) cout << "TRDrefit ";
  if((status & AliESDtrack::kTRDpid) == AliESDtrack::kTRDpid) cout << "TRDpid ";
  if((status & AliESDtrack::kTRDbackup) == AliESDtrack::kTRDbackup) cout << "TRDbackup ";
  if((status & AliESDtrack::kTRDStop) == AliESDtrack::kTRDStop) cout << "TRDstop ";

  if((status & AliESDtrack::kTOFin) == AliESDtrack::kTOFin) cout << "TOFin ";
  if((status & AliESDtrack::kTOFout) == AliESDtrack::kTOFout) cout << "TOFout ";
  if((status & AliESDtrack::kTOFrefit) == AliESDtrack::kTOFrefit) cout << "TOFrefit ";
  if((status & AliESDtrack::kTOFpid) == AliESDtrack::kTOFpid) cout << "TOFpid ";

  if((status & AliESDtrack::kPHOSpid) == AliESDtrack::kPHOSpid) cout << "PHOSpid ";
  if((status & AliESDtrack::kRICHpid) == AliESDtrack::kRICHpid) cout << "RICHpid ";
  if((status & AliESDtrack::kEMCALpid) == AliESDtrack::kEMCALpid) cout << "EMCALpid ";
  if((status & AliESDtrack::kESDpid) == AliESDtrack::kESDpid) cout << "ESDpid ";
  if((status & AliESDtrack::kTIME) == AliESDtrack::kTIME) cout << "TIME ";
  cout << endl; 
  /*
  cout << kesdtrack->GetConstrainedChi2() 
       << " " << kesdtrack->GetITSchi2()
       << " " << kesdtrack->GetTPCchi2() 
       << " " << kesdtrack->GetTRDchi2()<< endl;
  */
}
Commit	Line	Data
d7c6ab14	1	// $Id$
	2
	3	//____________________________________________________________________
	4	//////////////////////////////////////////////////////////////////////
	5	// //
	6	// class AliHBTReaderESD //
	7	// //
	8	// Reader for ALICE Event Summary Data (ESD). //
	9	// //
	10	// Piotr.Skowronski@cern.ch //
	11	// //
	12	//////////////////////////////////////////////////////////////////////
	13
d9a296b1	14	#include <Riostream.h>
d7c6ab14	15	#include <TMath.h>
	16	#include <TPDGCode.h>
	17	#include <TString.h>
	18	#include <TObjString.h>
	19	#include <TTree.h>
	20	#include <TFile.h>
	21	#include <TKey.h>
	22	#include <TH1.h>
	23	#include <AliESD.h>
	24	#include <AliESDtrack.h>
04a02430	25	#include <AliKalmanTrack.h>
d7c6ab14	26	#include <AliJetEventParticles.h>
	27	#include "AliJetParticlesReaderESD.h"
	28
	29	ClassImp(AliJetParticlesReaderESD)
	30
301a24f1	31	AliJetParticlesReaderESD::AliJetParticlesReaderESD(Bool_t constrained,
301a24f1	32	const Char_t* esdfilename) :
d7c6ab14	33	AliJetParticlesReader(),
301a24f1	34	fConstrained(constrained),
d7c6ab14	35	fESDFileName(esdfilename),
5d60c8f9	36	fESD(0),
d7c6ab14	37	fFile(0),
5d60c8f9	38	fTree(0),
d7c6ab14	39	fKeyIterator(0),
	40	fPassFlag(AliESDtrack::kTPCrefit)
	41	{
	42	//constructor
	43	}
	44
	45	/********************************************************************/
	46
	47	AliJetParticlesReaderESD::AliJetParticlesReaderESD(
301a24f1	48	Bool_t constrained,
d7c6ab14	49	TObjArray* dirs,
	50	const Char_t* esdfilename) :
	51	AliJetParticlesReader(dirs),
301a24f1	52	fConstrained(constrained),
d7c6ab14	53	fESDFileName(esdfilename),
5d60c8f9	54	fESD(0),
d7c6ab14	55	fFile(0),
5d60c8f9	56	fTree(0),
d7c6ab14	57	fKeyIterator(0),
	58	fPassFlag(AliESDtrack::kTPCrefit)
	59	{
	60	//constructor
	61	}
	62
	63	/********************************************************************/
	64
	65	AliJetParticlesReaderESD::~AliJetParticlesReaderESD()
	66	{
	67	//desctructor
5d60c8f9	68	if(fESD) delete fESD;
5d60c8f9	69	if(fTree) delete fTree;
d7c6ab14	70	if(fKeyIterator) delete fKeyIterator;
04a02430	71	if(fFile) delete fFile;
d7c6ab14	72	}
d7c6ab14	73
d7c6ab14	74	/**********************************************************/
	75
	76	Int_t AliJetParticlesReaderESD::ReadESD(AliESD* esd)
	77	{
	78	//Reads one ESD
	79
	80	if (esd == 0)
	81	{
	82	Error("ReadESD","ESD is NULL");
	83	return kFALSE;
	84	}
	85
	86	//TDatabasePDG* pdgdb = TDatabasePDG::Instance();
	87	//if (pdgdb == 0)
	88	//{
	89	// Error("ReadESD","Can not get PDG Database Instance.");
	90	// return kFALSE;
	91	// }
	92
04a02430	93	Float_t mf = esd->GetMagneticField();
	94	if (mf <= 0.0)
	95	{
	96	Error("ReadESD","Magnetic Field is 0. Skipping to next event.");
	97	return kFALSE;
	98	}
	99	AliKalmanTrack::SetMagneticField(mf/10.);
d7c6ab14	100
a86edc4e	101	Info("ReadESD","Reading Event %d",fCurrentDir*1000+fCurrentEvent);
d7c6ab14	102	if((!fOwner) \|\| (fEventParticles==0))
	103	fEventParticles = new AliJetEventParticles();
	104
04a02430	105	const Int_t kntr = esd->GetNumberOfTracks();
	106	Info("ReadESD","Found %d tracks.",kntr);
	107	fEventParticles->Reset(kntr);
	108
	109	TString headdesc="";
	110	headdesc+="Run ";
	111	headdesc+=esd->GetRunNumber();
	112	headdesc+=": Ev ";
	113	headdesc+=esd->GetEventNumber();
	114	fEventParticles->SetHeader(headdesc);
	115
d7c6ab14	116	Double_t vertexpos[3];//vertex position
	117	const AliESDVertex* kvertex = esd->GetVertex();
	118	if (kvertex == 0)
	119	{
	120	Info("ReadESD","ESD returned NULL pointer to vertex - assuming (0.0,0.0,0.0)");
	121	vertexpos[0] = 0.0;
	122	vertexpos[1] = 0.0;
	123	vertexpos[2] = 0.0;
	124	}
	125	else
	126	{
	127	kvertex->GetXYZ(vertexpos);
	128	}
	129	fEventParticles->SetVertex(vertexpos[0],vertexpos[1],vertexpos[2]);
	130
04a02430	131	//loop over tracks
d7c6ab14	132	for (Int_t i = 0;i<kntr; i++)
d7c6ab14	133	{
bad753b1	134
d7c6ab14	135	const AliESDtrack *kesdtrack = esd->GetTrack(i);
	136	if (kesdtrack == 0)
	137	{
04a02430	138	Error("ReadESD","Can't get track %d", i);
d7c6ab14	139	continue;
d7c6ab14	140	}
45cf33d2	141
	142	ULong_t cmptest=(kesdtrack->GetStatus() & fPassFlag);
	143	if (cmptest!=fPassFlag)
d7c6ab14	144	{
45cf33d2	145	Info("ReadNext","Particle %d skipped: %u.",i,kesdtrack->GetStatus());
9771a1a1	146	cout << i << " "; PrintESDtrack(kesdtrack); cout << endl;
d7c6ab14	147	continue;
	148	}
	149
	150	Double_t mom[3]; //momentum
301a24f1	151	Double_t xyz[3]; //position
	152	if (fConstrained) {
	153	if (kesdtrack->GetConstrainedChi2() > 25) continue;
	154	kesdtrack->GetConstrainedPxPyPz(mom);
	155	kesdtrack->GetConstrainedXYZ(xyz);
	156	} else {
9771a1a1	157	if(!kesdtrack->GetPxPyPzAt(0,mom)) continue;
	158	xyz[0]=0;xyz[1]=0;xyz[2]=0;
	159	//kesdtrack->GetPxPyPz(mom);
	160	//kesdtrack->GetXYZ(xyz);
301a24f1	161	}
d7c6ab14	162	const Float_t kmass=kesdtrack->GetMass();
	163	const Float_t kp2=mom[0]mom[0]+mom[1]mom[1]+mom[2]*mom[2];
	164	const Float_t ketot=TMath::Sqrt(kmass*kmass+kp2);
	165	const Float_t kpt=TMath::Sqrt(mom[0]mom[0]+mom[1]mom[1]);
	166	const Float_t kp=TMath::Sqrt(kp2);
	167	const Float_t keta=0.5*TMath::Log((kp+mom[2]+1e-30)/(kp-mom[2]+1e-30));
	168	const Float_t kphi=TMath::Pi()+TMath::ATan2(-mom[1],-mom[0]);
301a24f1	169	//Double_t dx = xyz[0]-vertexpos[0];
	170	//Double_t dy = xyz[1]-vertexpos[1];
	171	//Float_t dca = TMath::Sqrt(dxdx + dydy);
	172	//Float_t dz = xyz[2]-vertexpos[2];
	173	UInt_t index[6];
	174	const Int_t kncl=kesdtrack->GetITSclusters(index)
	175	+kesdtrack->GetTPCclusters(NULL)
	176	+kesdtrack->GetTRDclusters(NULL);
d7c6ab14	177	if(IsAcceptedParticle(kpt,kphi,keta))
301a24f1	178	fEventParticles->AddParticle(mom[0],mom[1],mom[2],ketot,i,kesdtrack->GetLabel(),kncl,kpt,kphi,keta);
d7c6ab14	179
	180	} // loop over tracks
	181
	182	return kTRUE;
	183	}
	184
	185	/**********************************************************/
	186
	187	void AliJetParticlesReaderESD::Rewind()
	188	{
	189	//rewinds reading
	190
	191	if(fFile) delete fFile;
	192	if(fKeyIterator) delete fKeyIterator;
	193	fKeyIterator = 0;
	194	fFile = 0;
	195	fCurrentDir = 0;
	196	fNEventsRead = 0;
	197	}
	198
	199	/**********************************************************/
	200
d9a296b1	201	Int_t AliJetParticlesReaderESD::ReadNext()
	202	{
	203	//reads next event from fFile
	204
	205	do // is OK even if 0 dirs specified,
	206	{ // in that case we try to read from "./"
	207	if (fFile == 0)
	208	{
	209	fFile = OpenFile(fCurrentDir);
	210	if (fFile == 0)
	211	{
	212	Error("ReadNext","Can't get fFile for dir no. %d",fCurrentDir);
	213	fCurrentDir++;
	214	continue;
	215	}
	216
	217	fCurrentEvent = 0;
	218	//fFile->GetListOfKeys()->Print();
	219
	220	if(fTree) delete fTree;
	221	fTree = dynamic_cast<TTree*>(fFile->Get("esdTree"));
	222	if(fTree)
	223	fTree->SetBranchAddress("ESD",&fESD);
	224	else
	225	fKeyIterator = new TIter(fFile->GetListOfKeys());
	226	}
	227
	228	if(fTree)
	229	{
	230	if(AliKalmanTrack::GetConvConst()<=0.)
	231	AliKalmanTrack::SetMagneticField(0.5);
	232	if(fCurrentEvent>=fTree->GetEntries())
	233	{
	234	fCurrentDir++;
	235	delete fTree;
	236	fTree = 0;
	237	delete fFile;
	238	fFile = 0;
	239	continue;
	240	}
	241	fTree->GetEvent(fCurrentEvent);
	242	}
	243	else
	244	{ // "old" way via ESD objects stored in root file
	245	TKey* key = (TKey*)fKeyIterator->Next();
	246	if (key == 0)
	247	{
	248	fCurrentDir++;
	249	delete fKeyIterator;
	250	fKeyIterator = 0;
	251	delete fFile; //we have to assume there are no more ESD objects in the fFile
	252	fFile = 0;
	253	continue;
	254	}
	255	TString esdname = "ESD";
	256	esdname+=fCurrentEvent;
	257	if(fESD) delete fESD;
	258	fESD = dynamic_cast<AliESD*>(fFile->Get(esdname));
	259	if (fESD == 0)
	260	{
	261	Info("ReadNext","Can't find AliESD object named %s",esdname.Data());
	262	fCurrentDir++;
	263	delete fKeyIterator;
	264	fKeyIterator = 0;
265	delete fFile;//we have to assume there is no more ESD objects in the fFile
266	fFile = 0;
267	continue;
268	}
269	}
270	ReadESD(fESD);
271	fCurrentEvent++;
272	fNEventsRead++;
273	return kTRUE;//success -> read one event
274	} while(fCurrentDir < GetNumberOfDirs());
275	//end of loop over directories specified in fDirs Obj Array
276	return kFALSE; //no more directories to read
277	}
278
279	/**********************************************************/
280
d7c6ab14	281	TFile* AliJetParticlesReaderESD::OpenFile(Int_t n)
	282	{
	283	//opens fFile with kine tree
	284
	285	const TString& dirname = GetDirName(n);
	286	if (dirname == "")
	287	{
04a02430	288	Error("OpenFiles","Can't get directory name");
d7c6ab14	289	return 0;
	290	}
	291	TString filename = dirname +"/"+ fESDFileName;
	292	TFile *ret = TFile::Open(filename.Data());
	293	if (ret == 0)
	294	{
	295	Error("OpenFiles","Can't open fFile %s",filename.Data());
	296	return 0;
	297	}
	298	if (!ret->IsOpen())
	299	{
	300	Error("OpenFiles","Can't open fFile %s",filename.Data());
	301	return 0;
	302	}
	303
	304	return ret;
	305	}
45cf33d2	306
	307	/**********************************************************/
	308
	309	void AliJetParticlesReaderESD::PrintESDtrack(const AliESDtrack *kesdtrack) const
	310	{
	311	ULong_t status=kesdtrack->GetStatus();
	312	cout << hex << status << dec << ": ";
	313	if((status & AliESDtrack::kITSin) == AliESDtrack::kITSin) cout << "ITSin ";
	314	if((status & AliESDtrack::kITSout) == AliESDtrack::kITSout) cout << "ITSout ";
	315	if((status & AliESDtrack::kITSrefit) == AliESDtrack::kITSrefit) cout << "ITSrefit ";
	316	if((status & AliESDtrack::kITSpid) == AliESDtrack::kITSpid) cout << "ITSpid ";
	317
	318	if((status & AliESDtrack::kTPCin) == AliESDtrack::kTPCin) cout << "TPCin ";
	319	if((status & AliESDtrack::kTPCout) == AliESDtrack::kTPCout) cout << "TPCout ";
	320	if((status & AliESDtrack::kTPCrefit) == AliESDtrack::kTPCrefit) cout << "TPCrefit ";
	321	if((status & AliESDtrack::kTPCpid) == AliESDtrack::kTPCpid) cout << "TPCpid ";
	322
	323	if((status & AliESDtrack::kTRDin) == AliESDtrack::kTRDin) cout << "TRDin ";
	324	if((status & AliESDtrack::kTRDout) == AliESDtrack::kTRDout) cout << "TRDout ";
	325	if((status & AliESDtrack::kTRDrefit) == AliESDtrack::kTRDrefit) cout << "TRDrefit ";
	326	if((status & AliESDtrack::kTRDpid) == AliESDtrack::kTRDpid) cout << "TRDpid ";
	327	if((status & AliESDtrack::kTRDbackup) == AliESDtrack::kTRDbackup) cout << "TRDbackup ";
	328	if((status & AliESDtrack::kTRDStop) == AliESDtrack::kTRDStop) cout << "TRDstop ";
	329
	330	if((status & AliESDtrack::kTOFin) == AliESDtrack::kTOFin) cout << "TOFin ";
	331	if((status & AliESDtrack::kTOFout) == AliESDtrack::kTOFout) cout << "TOFout ";
	332	if((status & AliESDtrack::kTOFrefit) == AliESDtrack::kTOFrefit) cout << "TOFrefit ";
	333	if((status & AliESDtrack::kTOFpid) == AliESDtrack::kTOFpid) cout << "TOFpid ";
	334
	335	if((status & AliESDtrack::kPHOSpid) == AliESDtrack::kPHOSpid) cout << "PHOSpid ";
	336	if((status & AliESDtrack::kRICHpid) == AliESDtrack::kRICHpid) cout << "RICHpid ";
	337	if((status & AliESDtrack::kEMCALpid) == AliESDtrack::kEMCALpid) cout << "EMCALpid ";
	338	if((status & AliESDtrack::kESDpid) == AliESDtrack::kESDpid) cout << "ESDpid ";
	339	if((status & AliESDtrack::kTIME) == AliESDtrack::kTIME) cout << "TIME ";
	340	cout << endl;
	341	/*
	342	cout << kesdtrack->GetConstrainedChi2()
	343	<< " " << kesdtrack->GetITSchi2()
	344	<< " " << kesdtrack->GetTPCchi2()
	345	<< " " << kesdtrack->GetTRDchi2()<< endl;
	346	*/
	347	}