[u/mrichter/AliRoot.git] / HBTAN / AliHBTReaderITSv2.cxx


#include "AliHBTReaderITSv2.h"

#include <Riostream.h>
#include <Riostream.h>
#include <TString.h>
#include <TObjString.h>
#include <TTree.h>
#include <TFile.h>
#include <TParticle.h>

#include <AliRun.h>
#include <AliMagF.h>
#include <AliITStrackV2.h>
//#include <AliITSParam.h>
#include <AliITStrackerV2.h>
#include <AliITSgeom.h>

#include "AliHBTRun.h"
#include "AliHBTEvent.h"
#include "AliHBTParticle.h"
#include "AliHBTParticleCut.h"


ClassImp(AliHBTReaderITSv2)

AliHBTReaderITSv2::
 AliHBTReaderITSv2(const Char_t* trackfilename, const Char_t* clusterfilename,
	const Char_t* galicefilename)
                  :fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
                    fGAliceFileName(galicefilename)
{
  //constructor, 
  //Defaults:
  //  trackfilename = "AliITStracksV2.root"
  //  clusterfilename = "AliITSclustersV2.root"
  //  galicefilename = "galice.root"
  fParticles = new AliHBTRun();
  fTracks    = new AliHBTRun();
  fIsRead = kFALSE;
}
/********************************************************************/

AliHBTReaderITSv2::
 AliHBTReaderITSv2(TObjArray* dirs, const Char_t* trackfilename, 
                   const Char_t* clusterfilename, const Char_t* galicefilename)
                  : AliHBTReader(dirs),
                    fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
                    fGAliceFileName(galicefilename)
{
  //constructor, 
  //Defaults:
  //  trackfilename = "AliITStracksV2.root"
  //  clusterfilename = "AliITSclustersV2.root"
  //  galicefilename = "galice.root"
  
  fParticles = new AliHBTRun();
  fTracks    = new AliHBTRun();
  fIsRead = kFALSE;
}
/********************************************************************/

AliHBTReaderITSv2::~AliHBTReaderITSv2()
 {
   if (fParticles) delete fParticles;
   if (fTracks) delete fTracks;
 }
/********************************************************************/
/********************************************************************/

AliHBTEvent* AliHBTReaderITSv2::GetParticleEvent(Int_t n)
 {
 //returns Nth event with simulated particles
   if (!fIsRead) 
    if(Read(fParticles,fTracks))
     {
       Error("GetParticleEvent","Error in reading");
       return 0x0;
     }

   return fParticles->GetEvent(n);
 }
/********************************************************************/

AliHBTEvent* AliHBTReaderITSv2::GetTrackEvent(Int_t n)
 {
 //returns Nth event with reconstructed tracks
   if (!fIsRead) 
    if(Read(fParticles,fTracks))
     {
       Error("GetTrackEvent","Error in reading");
       return 0x0;
     }
   return fTracks->GetEvent(n);
 }
/********************************************************************/

Int_t AliHBTReaderITSv2::GetNumberOfPartEvents()
 {
 //returns number of events of particles
   if (!fIsRead)
    if(Read(fParticles,fTracks))
     {
       Error("GetNumberOfPartEvents","Error in reading");
       return 0;
     }
   return fParticles->GetNumberOfEvents();
 }

/********************************************************************/
Int_t AliHBTReaderITSv2::GetNumberOfTrackEvents()
 {
 //returns number of events of tracks
  if (!fIsRead) 
    if(Read(fParticles,fTracks))
     {
       Error("GetNumberOfTrackEvents","Error in reading");
       return 0;
     }
  return fTracks->GetNumberOfEvents();
 }


/********************************************************************/
/********************************************************************/
Int_t AliHBTReaderITSv2::Read(AliHBTRun* particles, AliHBTRun *tracks)
{
 Int_t Nevents = 0; //number of events found in given directory
 Int_t Ndirs; //number of the directories to be read
 Int_t Ntracks; //number of tracks in current event
 Int_t currentdir = 0; //number of events in the current directory 
 Int_t totalNevents = 0; //total number of events read from all directories up to now
 register Int_t i; //iterator
 
 TFile *aTracksFile;//file with tracks
 TFile *aClustersFile;//file with clusters
 TFile *aGAliceFile;//file name with galice

// AliITStrackerV2 *tracker; // ITS tracker - used for cooking labels
 TTree *tracktree; // tree for tracks
 
 Double_t xk;
 Double_t par[5]; //Kalman track parameters
 Float_t phi, lam, pt;//angles and transverse momentum
 Int_t label; //label of the current track

 char tname[100]; //buffer for tree name
 AliITStrackV2 *iotrack= new AliITStrackV2(); //buffer track for reading data from tree

 if (!particles) //check if an object is instatiated
  {
    Error("Read"," particles object must instatiated before passing it to the reader");
  }
 if (!tracks)  //check if an object is instatiated
  {
    Error("Read"," tracks object must instatiated before passing it to the reader");
  }
 particles->Reset();//clear runs == delete all old events
 tracks->Reset();

 if (fDirs) //if array with directories is supplied by user
  {
    Ndirs = fDirs->GetEntries(); //get the number if directories
  }
 else
  {
    Ndirs = 0; //if the array is not supplied read only from current directory
  }
 
// cout<<"Found "<<Ndirs<<" directory entries"<<endl;
 
 do //do while is good even if Ndirs==0 (than read from current directory)
   {
    if( (i=OpenFiles(aTracksFile,aClustersFile,aGAliceFile,currentdir)) )
     {
       Error("Read","Exiting due to problems with opening files. Errorcode %d",i);
       currentdir++;
       continue;
     }
    
    if (gAlice->TreeE())//check if tree E exists
     {
      Nevents = (Int_t)gAlice->TreeE()->GetEntries();//if yes get number of events in gAlice
      cout<<"________________________________________________________\n";
      cout<<"Found "<<Nevents<<" event(s) in directory "<<GetDirName(currentdir)<<endl;
      cout<<"Setting Magnetic Field: B="<<gAlice->Field()->SolenoidField()<<"T"<<endl;
      AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
     }
    else
     {//if not return an error
       Error("Read","Can not find Header tree (TreeE) in gAlice");
       currentdir++;
       continue;
     }
    
    AliITSgeom *geom=(AliITSgeom*)aClustersFile->Get("AliITSgeom");
    if (!geom) 
     { 
       Error("Read","Can't get the ITS geometry!"); 
       currentdir++;
       continue;
     }

    for(Int_t currentEvent =0; currentEvent<Nevents;currentEvent++)//loop over all events
     {
       cout<<"Reading Event "<<currentEvent<<endl;
       
       aGAliceFile->cd();
       gAlice->GetEvent(currentEvent);

       aClustersFile->cd();
       sprintf(tname,"TreeT_ITS_%d",currentEvent);
       
       tracktree=(TTree*)aTracksFile->Get(tname);
       if (!tracktree) 
         {
           Error("Read","Can't get a tree with ITS tracks"); 
           continue;
         }
       TBranch *tbranch=tracktree->GetBranch("tracks");
      
       Ntracks=(Int_t)tracktree->GetEntries();

       Int_t accepted = 0;
       Int_t tpcfault = 0;
       Int_t itsfault = 0;
       for (i=0; i<Ntracks; i++) //loop over all tpc tracks
        { 
          if(i%100 == 0)cout<<"all: "<<i<<"   accepted: "<<accepted<<"   tpc faults: "<<tpcfault<<"\r";
          
          tbranch->SetAddress(&iotrack);
          tracktree->GetEvent(i);

          label=iotrack->GetLabel();
          if (label < 0) 
           {
             tpcfault++;
             continue;
           }

          TParticle *p = (TParticle*)gAlice->Particle(label);
          if(p == 0x0) continue; //if returned pointer is NULL
          if(p->GetPDG() == 0x0) continue; //if particle has crezy PDG code (not known to our database)

          if(Pass(p->GetPdgCode())) continue; //check if we are intersted with particles of this type 
                                              //if not take next partilce
            
          AliHBTParticle* part = new AliHBTParticle(*p);
          if(Pass(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
                                                  //if it does not delete it and take next good track

          
          iotrack->PropagateTo(3.,0.0028,65.19);
          iotrack->PropagateToVertex();
 
          iotrack->GetExternalParameters(xk,par);     //get properties of the track
          phi=TMath::ASin(par[2]) + iotrack->GetAlpha(); 
          if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
          if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
          lam=par[3]; 
          pt=1.0/TMath::Abs(par[4]);
            
          Double_t tpx = pt * TMath::Cos(phi); //track x coordinate of momentum
          Double_t tpy = pt * TMath::Sin(phi); //track y coordinate of momentum
          Double_t tpz = pt * lam; //track z coordinate of momentum
           
          Double_t mass = p->GetMass();
          Double_t tEtot = TMath::Sqrt( tpx*tpx + tpy*tpy + tpz*tpz + mass*mass);//total energy of the track
            
          AliHBTParticle* track = new AliHBTParticle(p->GetPdgCode(), tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
          if(Pass(track))//check if meets all criteria of any of our cuts
                         //if it does not delete it and take next good track
           { 
            delete track;
            delete part;
            continue;
           }
          particles->AddParticle(totalNevents,part);//put track and particle on the run
          tracks->AddParticle(totalNevents,track);
          accepted++;
        }//end of loop over tracks in the event
        
       aTracksFile->Delete(tname);
       aTracksFile->Delete("tracks");
//       delete tracker;
       
       totalNevents++;
       cout<<"all: "<<i<<"   accepted: "<<accepted<<"   tpc faults: "<<tpcfault<<"   its faults: "<<itsfault<<endl;
     
     }//end of loop over events in current directory
    CloseFiles(aTracksFile,aClustersFile,aGAliceFile);     
    currentdir++;
   }while(currentdir < Ndirs);//end of loop over directories specified in fDirs Obj Array

 delete iotrack;
 fIsRead = kTRUE;
 return 0;
}

/********************************************************************/
Int_t AliHBTReaderITSv2::OpenFiles
(TFile*& aTracksFile, TFile*& aClustersFile, TFile*& agAliceFile,Int_t event)
{
 //opens all the files
   
   
   const TString& dirname = GetDirName(event); 
   if (dirname == "")
    {
      Error("OpenFiles","Can not get directory name");
      return 4;
    }
   
   TString filename = dirname +"/"+ fTrackFileName;
   aTracksFile = TFile::Open(filename.Data());
   if ( aTracksFile  == 0x0 ) 
     {
       Error("OpenFiles","Can't open file with tacks named %s",filename.Data());
       return 1;
     }
   if (!aTracksFile->IsOpen())
     {
       Error("OpenFiles","Can't open file with tacks named %s",filename.Data());
       return 1;
     }
  
   filename = dirname +"/"+ fClusterFileName;
   aClustersFile = TFile::Open(filename.Data());
   if ( aClustersFile == 0x0 )
    {
      Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
      return 2;
    }
   if (!aClustersFile->IsOpen())
    {
      Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
      return 2;
    }

   filename = dirname +"/"+ fGAliceFileName;
   agAliceFile = TFile::Open(filename.Data());
   if ( agAliceFile== 0x0)
    {
      Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
      return 3;
    }
   if (!agAliceFile->IsOpen())
    {
      Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
      return 3;
    } 
   
   if (!(gAlice=(AliRun*)agAliceFile->Get("gAlice"))) 
    {
      Error("OpenFiles","gAlice have not been found on %s !\n",filename.Data());
      return 5;
    }

   return 0; 
}
/********************************************************************/

/********************************************************************/
  
void AliHBTReaderITSv2::CloseFiles(TFile*& tracksFile, TFile*& clustersFile, TFile*& gAliceFile)
{
  //closes the files
  tracksFile->Close();
  delete tracksFile;
  tracksFile = 0x0;
  
  clustersFile->Close();
  delete clustersFile;
  clustersFile = 0x0;
  
  delete gAlice;
  gAlice = 0;

  if (gAliceFile) 
   {
     gAliceFile->Close();
     delete gAliceFile;
     gAliceFile = 0x0;
   }
}

/********************************************************************/
Commit	Line	Data
1b446896	1
	2	#include "AliHBTReaderITSv2.h"
	3
d0c23b58	4	#include <Riostream.h>
d0c23b58	5	#include <Riostream.h>
a9bfdd7b	6	#include <TString.h>
	7	#include <TObjString.h>
	8	#include <TTree.h>
	9	#include <TFile.h>
	10	#include <TParticle.h>
	11
	12	#include <AliRun.h>
	13	#include <AliMagF.h>
	14	#include <AliITStrackV2.h>
	15	//#include <AliITSParam.h>
	16	#include <AliITStrackerV2.h>
	17	#include <AliITSgeom.h>
	18
	19	#include "AliHBTRun.h"
	20	#include "AliHBTEvent.h"
	21	#include "AliHBTParticle.h"
	22	#include "AliHBTParticleCut.h"
	23
	24
1b446896	25	ClassImp(AliHBTReaderITSv2)
1b446896	26
a9bfdd7b	27	AliHBTReaderITSv2::
	28	AliHBTReaderITSv2(const Char_t* trackfilename, const Char_t* clusterfilename,
	29	const Char_t* galicefilename)
	30	:fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
	31	fGAliceFileName(galicefilename)
	32	{
	33	//constructor,
	34	//Defaults:
	35	// trackfilename = "AliITStracksV2.root"
	36	// clusterfilename = "AliITSclustersV2.root"
	37	// galicefilename = "galice.root"
	38	fParticles = new AliHBTRun();
	39	fTracks = new AliHBTRun();
	40	fIsRead = kFALSE;
	41	}
	42	/********************************************************************/
	43
	44	AliHBTReaderITSv2::
	45	AliHBTReaderITSv2(TObjArray* dirs, const Char_t* trackfilename,
	46	const Char_t* clusterfilename, const Char_t* galicefilename)
	47	: AliHBTReader(dirs),
	48	fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
	49	fGAliceFileName(galicefilename)
	50	{
	51	//constructor,
	52	//Defaults:
	53	// trackfilename = "AliITStracksV2.root"
	54	// clusterfilename = "AliITSclustersV2.root"
	55	// galicefilename = "galice.root"
	56
	57	fParticles = new AliHBTRun();
	58	fTracks = new AliHBTRun();
	59	fIsRead = kFALSE;
	60	}
	61	/********************************************************************/
	62
	63	AliHBTReaderITSv2::~AliHBTReaderITSv2()
	64	{
	65	if (fParticles) delete fParticles;
	66	if (fTracks) delete fTracks;
	67	}
	68	/********************************************************************/
	69	/********************************************************************/
	70
	71	AliHBTEvent* AliHBTReaderITSv2::GetParticleEvent(Int_t n)
	72	{
	73	//returns Nth event with simulated particles
	74	if (!fIsRead)
	75	if(Read(fParticles,fTracks))
	76	{
	77	Error("GetParticleEvent","Error in reading");
	78	return 0x0;
	79	}
	80
	81	return fParticles->GetEvent(n);
	82	}
	83	/********************************************************************/
	84
	85	AliHBTEvent* AliHBTReaderITSv2::GetTrackEvent(Int_t n)
	86	{
	87	//returns Nth event with reconstructed tracks
	88	if (!fIsRead)
	89	if(Read(fParticles,fTracks))
	90	{
91	Error("GetTrackEvent","Error in reading");
92	return 0x0;
93	}
94	return fTracks->GetEvent(n);
95	}
96	/********************************************************************/
97
98	Int_t AliHBTReaderITSv2::GetNumberOfPartEvents()
99	{
100	//returns number of events of particles
101	if (!fIsRead)
102	if(Read(fParticles,fTracks))
103	{
104	Error("GetNumberOfPartEvents","Error in reading");
105	return 0;
106	}
107	return fParticles->GetNumberOfEvents();
108	}
109
110	/********************************************************************/
111	Int_t AliHBTReaderITSv2::GetNumberOfTrackEvents()
112	{
113	//returns number of events of tracks
114	if (!fIsRead)
115	if(Read(fParticles,fTracks))
116	{
117	Error("GetNumberOfTrackEvents","Error in reading");
118	return 0;
119	}
120	return fTracks->GetNumberOfEvents();
121	}
122
123
124	/********************************************************************/
125	/********************************************************************/
126	Int_t AliHBTReaderITSv2::Read(AliHBTRun* particles, AliHBTRun *tracks)
127	{
128	Int_t Nevents = 0; //number of events found in given directory
129	Int_t Ndirs; //number of the directories to be read
130	Int_t Ntracks; //number of tracks in current event
131	Int_t currentdir = 0; //number of events in the current directory
132	Int_t totalNevents = 0; //total number of events read from all directories up to now
133	register Int_t i; //iterator
134
135	TFile *aTracksFile;//file with tracks
136	TFile *aClustersFile;//file with clusters
137	TFile *aGAliceFile;//file name with galice
138
41515b05	139	// AliITStrackerV2 *tracker; // ITS tracker - used for cooking labels
a9bfdd7b	140	TTree *tracktree; // tree for tracks
	141
	142	Double_t xk;
	143	Double_t par[5]; //Kalman track parameters
	144	Float_t phi, lam, pt;//angles and transverse momentum
	145	Int_t label; //label of the current track
	146
	147	char tname[100]; //buffer for tree name
	148	AliITStrackV2 *iotrack= new AliITStrackV2(); //buffer track for reading data from tree
	149
	150	if (!particles) //check if an object is instatiated
	151	{
	152	Error("Read"," particles object must instatiated before passing it to the reader");
	153	}
	154	if (!tracks) //check if an object is instatiated
	155	{
	156	Error("Read"," tracks object must instatiated before passing it to the reader");
	157	}
	158	particles->Reset();//clear runs == delete all old events
	159	tracks->Reset();
	160
	161	if (fDirs) //if array with directories is supplied by user
	162	{
	163	Ndirs = fDirs->GetEntries(); //get the number if directories
	164	}
	165	else
	166	{
	167	Ndirs = 0; //if the array is not supplied read only from current directory
	168	}
	169
	170	// cout<<"Found "<<Ndirs<<" directory entries"<<endl;
	171
	172	do //do while is good even if Ndirs==0 (than read from current directory)
	173	{
	174	if( (i=OpenFiles(aTracksFile,aClustersFile,aGAliceFile,currentdir)) )
	175	{
	176	Error("Read","Exiting due to problems with opening files. Errorcode %d",i);
5ee8b891	177	currentdir++;
5ee8b891	178	continue;
a9bfdd7b	179	}
	180
	181	if (gAlice->TreeE())//check if tree E exists
	182	{
	183	Nevents = (Int_t)gAlice->TreeE()->GetEntries();//if yes get number of events in gAlice
	184	cout<<"________________________________________________________\n";
	185	cout<<"Found "<<Nevents<<" event(s) in directory "<<GetDirName(currentdir)<<endl;
5ee8b891	186	cout<<"Setting Magnetic Field: B="<<gAlice->Field()->SolenoidField()<<"T"<<endl;
5ee8b891	187	AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
a9bfdd7b	188	}
	189	else
	190	{//if not return an error
	191	Error("Read","Can not find Header tree (TreeE) in gAlice");
5ee8b891	192	currentdir++;
5ee8b891	193	continue;
a9bfdd7b	194	}
	195
	196	AliITSgeom geom=(AliITSgeom)aClustersFile->Get("AliITSgeom");
	197	if (!geom)
	198	{
	199	Error("Read","Can't get the ITS geometry!");
5ee8b891	200	currentdir++;
5ee8b891	201	continue;
a9bfdd7b	202	}
	203
	204	for(Int_t currentEvent =0; currentEvent<Nevents;currentEvent++)//loop over all events
	205	{
	206	cout<<"Reading Event "<<currentEvent<<endl;
	207
	208	aGAliceFile->cd();
	209	gAlice->GetEvent(currentEvent);
9f69cb10	210
a9bfdd7b	211	aClustersFile->cd();
a9bfdd7b	212	sprintf(tname,"TreeT_ITS_%d",currentEvent);
	213
	214	tracktree=(TTree*)aTracksFile->Get(tname);
	215	if (!tracktree)
	216	{
	217	Error("Read","Can't get a tree with ITS tracks");
5ee8b891	218	continue;
a9bfdd7b	219	}
	220	TBranch *tbranch=tracktree->GetBranch("tracks");
	221
	222	Ntracks=(Int_t)tracktree->GetEntries();
	223
	224	Int_t accepted = 0;
	225	Int_t tpcfault = 0;
	226	Int_t itsfault = 0;
	227	for (i=0; i<Ntracks; i++) //loop over all tpc tracks
	228	{
9f69cb10	229	if(i%100 == 0)cout<<"all: "<<i<<" accepted: "<<accepted<<" tpc faults: "<<tpcfault<<"\r";
a9bfdd7b	230
	231	tbranch->SetAddress(&iotrack);
	232	tracktree->GetEvent(i);
	233
	234	label=iotrack->GetLabel();
	235	if (label < 0)
	236	{
	237	tpcfault++;
	238	continue;
	239	}
a9bfdd7b	240
a9bfdd7b	241	TParticle p = (TParticle)gAlice->Particle(label);
f1e2da22	242	if(p == 0x0) continue; //if returned pointer is NULL
	243	if(p->GetPDG() == 0x0) continue; //if particle has crezy PDG code (not known to our database)
	244
a9bfdd7b	245	if(Pass(p->GetPdgCode())) continue; //check if we are intersted with particles of this type
	246	//if not take next partilce
	247
	248	AliHBTParticle* part = new AliHBTParticle(*p);
	249	if(Pass(part)) { delete part; continue;}//check if meets all criteria of any of our cuts
	250	//if it does not delete it and take next good track
	251
	252
5f119c5b	253	iotrack->PropagateTo(3.,0.0028,65.19);
a9bfdd7b	254	iotrack->PropagateToVertex();
	255
	256	iotrack->GetExternalParameters(xk,par); //get properties of the track
	257	phi=TMath::ASin(par[2]) + iotrack->GetAlpha();
	258	if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
	259	if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
	260	lam=par[3];
	261	pt=1.0/TMath::Abs(par[4]);
	262
	263	Double_t tpx = pt * TMath::Cos(phi); //track x coordinate of momentum
	264	Double_t tpy = pt * TMath::Sin(phi); //track y coordinate of momentum
	265	Double_t tpz = pt * lam; //track z coordinate of momentum
	266
	267	Double_t mass = p->GetMass();
	268	Double_t tEtot = TMath::Sqrt( tpxtpx + tpytpy + tpztpz + massmass);//total energy of the track
	269
	270	AliHBTParticle* track = new AliHBTParticle(p->GetPdgCode(), tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
	271	if(Pass(track))//check if meets all criteria of any of our cuts
	272	//if it does not delete it and take next good track
	273	{
	274	delete track;
	275	delete part;
	276	continue;
	277	}
	278	particles->AddParticle(totalNevents,part);//put track and particle on the run
	279	tracks->AddParticle(totalNevents,track);
	280	accepted++;
	281	}//end of loop over tracks in the event
	282
	283	aTracksFile->Delete(tname);
	284	aTracksFile->Delete("tracks");
41515b05	285	// delete tracker;
a9bfdd7b	286
a9bfdd7b	287	totalNevents++;
a9bfdd7b	288	cout<<"all: "<<i<<" accepted: "<<accepted<<" tpc faults: "<<tpcfault<<" its faults: "<<itsfault<<endl;
	289
	290	}//end of loop over events in current directory
7836ee94	291	CloseFiles(aTracksFile,aClustersFile,aGAliceFile);
7836ee94	292	currentdir++;
a9bfdd7b	293	}while(currentdir < Ndirs);//end of loop over directories specified in fDirs Obj Array
	294
	295	delete iotrack;
	296	fIsRead = kTRUE;
	297	return 0;
	298	}
	299
	300	/********************************************************************/
	301	Int_t AliHBTReaderITSv2::OpenFiles
	302	(TFile& aTracksFile, TFile& aClustersFile, TFile*& agAliceFile,Int_t event)
	303	{
	304	//opens all the files
	305
	306
	307	const TString& dirname = GetDirName(event);
	308	if (dirname == "")
	309	{
	310	Error("OpenFiles","Can not get directory name");
	311	return 4;
	312	}
	313
	314	TString filename = dirname +"/"+ fTrackFileName;
	315	aTracksFile = TFile::Open(filename.Data());
	316	if ( aTracksFile == 0x0 )
	317	{
	318	Error("OpenFiles","Can't open file with tacks named %s",filename.Data());
	319	return 1;
	320	}
	321	if (!aTracksFile->IsOpen())
	322	{
	323	Error("OpenFiles","Can't open file with tacks named %s",filename.Data());
	324	return 1;
	325	}
	326
	327	filename = dirname +"/"+ fClusterFileName;
	328	aClustersFile = TFile::Open(filename.Data());
	329	if ( aClustersFile == 0x0 )
	330	{
	331	Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
	332	return 2;
	333	}
	334	if (!aClustersFile->IsOpen())
	335	{
	336	Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
	337	return 2;
	338	}
	339
	340	filename = dirname +"/"+ fGAliceFileName;
	341	agAliceFile = TFile::Open(filename.Data());
	342	if ( agAliceFile== 0x0)
	343	{
	344	Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
	345	return 3;
	346	}
	347	if (!agAliceFile->IsOpen())
	348	{
	349	Error("OpenFiles","Can't open file with TPC clusters named %s",filename.Data());
	350	return 3;
	351	}
	352
	353	if (!(gAlice=(AliRun*)agAliceFile->Get("gAlice")))
	354	{
	355	Error("OpenFiles","gAlice have not been found on %s !\n",filename.Data());
	356	return 5;
357	}
358
359	return 0;
360	}
361	/********************************************************************/
362
363	/********************************************************************/
364
365	void AliHBTReaderITSv2::CloseFiles(TFile& tracksFile, TFile& clustersFile, TFile*& gAliceFile)
366	{
367	//closes the files
368	tracksFile->Close();
369	delete tracksFile;
370	tracksFile = 0x0;
371
372	clustersFile->Close();
373	delete clustersFile;
374	clustersFile = 0x0;
375
376	delete gAlice;
377	gAlice = 0;
378
379	if (gAliceFile)
380	{
381	gAliceFile->Close();
382	delete gAliceFile;
383	gAliceFile = 0x0;
384	}
385	}
386
387	/********************************************************************/
388
389