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

#include "AliHBTReaderPPprod.h"

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

#include <AliTPCtrack.h>
#include <AliTPCParam.h>
#include <AliTPCtracker.h>

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


ClassImp(AliHBTReaderPPprod)

AliHBTReaderPPprod::
 AliHBTReaderPPprod(const Char_t* trackfilename,const Char_t* clusterfilename,
                 const Char_t* goodtracksfilename,const Char_t* galicefilename):
                 fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
                 fGAliceFileName(galicefilename),
                 fGoodTPCTracksFileName(goodtracksfilename)
{
  //constructor, only file names are set
  //Defaults:
  //  trackfilename = "AliTPCtracks.root"
  //  clusterfilename = "AliTPCclusters.root"
  //  goodtracksfilename = "good_tracks_tpc"
  //  galicefilename = ""  - this means: Do not open gAlice file - 
  //                         just leave the global pointer untached
  
  fParticles = new AliHBTRun();
  fTracks    = new AliHBTRun();

  fTracksFile   = 0x0;  //files are opened during reading only
  fClustersFile = 0x0;
  
  fIsRead = kFALSE;
}
/********************************************************************/

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

AliHBTEvent* AliHBTReaderPPprod::GetParticleEvent(Int_t n)
 {
 //returns Nth event with simulated particles
   if (!fIsRead) Read(fParticles,fTracks);
   return fParticles->GetEvent(n);
 }
/********************************************************************/
AliHBTEvent* AliHBTReaderPPprod::GetTrackEvent(Int_t n)
 {
 //returns Nth event with reconstructed tracks
   if (!fIsRead) Read(fParticles,fTracks);
   return fTracks->GetEvent(n);
 }
/********************************************************************/

Int_t AliHBTReaderPPprod::GetNumberOfPartEvents()
 {
 //returns number of events of particles
   if (!fIsRead) Read(fParticles,fTracks);
   return fParticles->GetNumberOfEvents();
 }

/********************************************************************/
Int_t AliHBTReaderPPprod::GetNumberOfTrackEvents()
 {
 //returns number of events of tracks
  if (!fIsRead) Read(fParticles,fTracks);
  return fTracks->GetNumberOfEvents();
 }
/********************************************************************/


Int_t AliHBTReaderPPprod::Read(AliHBTRun* particles, AliHBTRun *tracks)
 {
 //reads data and puts put to the particles and tracks objects
 //reurns 0 if everything is OK
 //
  cout<<"New I/O not implemented\n";
  return 0;
   
  Int_t i; //iterator and some temprary values
  Int_t Nevents;
  if (!particles) //check if an object is instatiated
   {
     Error("AliHBTReaderPPprod::Read"," particles object must instatiated before passing it to the reader");
   }
  if (!tracks)  //check if an object is instatiated
   {
     Error("AliHBTReaderPPprod::Read"," tracks object must instatiated before passing it to the reader");
   }
  particles->Reset();//clear runs == delete all old events
  tracks->Reset();
    
  if( (i=OpenFiles()) )
   {
     Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
     return i;
   }
  
  AliGoodTracksPP *goodTPCTracks = new AliGoodTracksPP(fGoodTPCTracksFileName);
  if (!goodTPCTracks)
   {
     Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
     return 1;
   }

  Nevents = 100;

  fClustersFile->cd();
  AliTPCParam *TPCParam= (AliTPCParam*)fClustersFile->Get("75x40_100x60");
  if (!TPCParam) 
    { 
     Error("AliHBTReaderPPprod::Read","TPC parameters have not been found !\n");
     return 1;
    }

  TObjArray *tarray = new TObjArray(5000);
  tarray->SetOwner();//  this causes memory leak, but in some cases deleting is infinite loop
  
 
  for(Int_t currentEvent =0; currentEvent<Nevents;currentEvent++)
   {
     cout<<"Reading Event "<<currentEvent<<endl;
     /**************************************/
      /**************************************/
       /**************************************/ 
         fTracksFile->cd();
         Char_t  treename[100];
         sprintf(treename,"TreeT_TPC_%d",currentEvent);
   
         TTree *tracktree=0;
         
         tracktree=(TTree*)fTracksFile->Get(treename);
         if (!tracktree) 
          {
            Error("AliHBTReaderPPprod::Read","Can't get a tree with TPC tracks !\n"); 
            return 1;
          }
   
         TBranch *trackbranch=tracktree->GetBranch("tracks");
         if (!trackbranch) 
          {
            Error("AliHBTReaderPPprod::Read","Can't get a branch with TPC tracks !\n"); 
            return 2;
          }
         Int_t NTPCtracks=(Int_t)tracktree->GetEntries();
         cout<<"Found "<<NTPCtracks<<" TPC tracks.\n";
         //Copy tracks to array
         
         AliTPCtrack *iotrack=0;
         
         fClustersFile->cd();
printf("This method is not converted to the NewIO !\n"); //I.B.
return 1; //I.B.
         AliTPCtracker *tracker = new AliTPCtracker(TPCParam); //I.B.
         //AliTPCtracker *tracker = new AliTPCtracker(TPCParam,currentEvent,"");
         if (!tracker) 
          {
            Error("AliHBTReaderPPprod::Read","Can't get a tracker !\n"); 
            return 3;
          }
tracker->LoadClusters(0);//I.Belikov, "0" should be a pointer to a tree
   
         for (i=0; i<NTPCtracks; i++)
          {
            iotrack=new AliTPCtrack;
            trackbranch->SetAddress(&iotrack);
            tracktree->GetEvent(i);
            tracker->CookLabel(iotrack,0.1);
            tarray->AddLast(iotrack);
          }
        
         
         fTracksFile->Delete(treename);//delete tree from memmory (and leave untached on disk)- we do not need it any more
         fTracksFile->Delete("tracks");
         
         delete tracker;
         
         tracker = 0x0;
         trackbranch = 0x0;
         tracktree = 0x0;

         Int_t & ngood = goodTPCTracks->fGoodInEvent[currentEvent];
   
         Double_t xk;
         Double_t par[5];
         Float_t phi, lam, pt;
         Int_t label;
         Bool_t found;
   
         for (i=0; i<ngood; i++)
          { 
            const struct GoodTrack & gt = goodTPCTracks->GetTrack(currentEvent,i);
            
            if(Pass(gt.code)) continue;
            
            label = gt.lab;
            found = kFALSE; //guard in case we don't find track with such a label
            for (Int_t j=0;j<NTPCtracks;j++)
              {
                iotrack = (AliTPCtrack*)tarray->At(j);
                if (iotrack->GetLabel() == label) 
                  {
                    found = kTRUE;
                    break;
                  }
              }  
            if(!found) 
              {
                Warning("Read",
                "Sth is going wrong with tracks - there is no TPC track corresponding to goodtrack.\nGood tack label %d",label);
                continue; //put comunicate on the screen and continue loop
              }
        
            Double_t mass = TDatabasePDG::Instance()->GetParticle(gt.code)->Mass();
            Double_t pEtot = TMath::Sqrt(gt.px*gt.px + gt.py*gt.py + gt.pz*gt.pz + mass*mass);
            
            AliHBTParticle* part = new AliHBTParticle(gt.code,i, gt.px, gt.py, gt.pz, pEtot, gt.x, gt.y, gt.z, 0.0);
            if(Pass(part)) continue;
            
         
            iotrack->PropagateTo(gt.x);
            iotrack->GetExternalParameters(xk,par);
            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 x coordinate of momentum
            Double_t tpz = pt * lam;
            
            Double_t tEtot = TMath::Sqrt( tpx*tpx + tpy*tpy + tpz*tpz + mass*mass);
            
            AliHBTParticle* track = new AliHBTParticle(gt.code,i, tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
            if(Pass(track)) continue;
            
            particles->AddParticle(currentEvent,part);
            tracks->AddParticle(currentEvent,track);

          }
         tarray->Clear();
       /**************************************/
      /**************************************/
     /**************************************/  
   }
  
  CloseFiles();
  delete tarray;
  delete goodTPCTracks;
  fIsRead = kTRUE;
  return 0;
 }

/********************************************************************/
Int_t AliHBTReaderPPprod::OpenFiles()
{
 
   fTracksFile = 0;
   fTracksFile=TFile::Open("AliTPCtracks.root");
   if (!fTracksFile->IsOpen()) 
     {
       Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCtracks.root");
       return 1;
     }
   
   fClustersFile = 0;
   
   fClustersFile=TFile::Open("AliTPCclusters.root");
   if (!fClustersFile->IsOpen()) 
    {
      Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCclusters.root");
      return 2;
    }

    
 return 0; 
}
  

/********************************************************************/
  
void AliHBTReaderPPprod::CloseFiles()
{
  fTracksFile->Close();
  fClustersFile->Close();
}

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

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


AliGoodTracksPP::~AliGoodTracksPP()
{
 delete [] fGoodInEvent;
 for (Int_t i = 0;i<fNevents;i++)
   delete [] fData[i];
 delete [] fData;
}
/********************************************************************/
AliGoodTracksPP::AliGoodTracksPP(const TString& infilename)
{

  fNevents = 100;
  ifstream in(infilename.Data());

  if(!in)
    {
      cerr<<"Can not open file with Good TPC Tracks named:"<<infilename.Data()<<endl;
      delete this;
      return;
    }

  
  fGoodInEvent = new Int_t[fNevents];
  fData = new struct GoodTrack* [fNevents];

  Int_t i;
  for( i = 0;i<fNevents;i++)
   {
    fGoodInEvent[i] =0;
    fData[i] = new struct GoodTrack[500];
   }
  Float_t tmp;
  Int_t evno;
  while(in>>evno)
   {
    if(fGoodInEvent[evno]>=500)
     {
      cerr<<"AliGoodTracksPP::AliGoodTracksPP() : Not enough place in the array\n";
      continue;
     }
    in>>fData[evno][fGoodInEvent[evno]].lab;
    in>>fData[evno][fGoodInEvent[evno]].code;
    in>>fData[evno][fGoodInEvent[evno]].px;
    in>>fData[evno][fGoodInEvent[evno]].py;
    in>>fData[evno][fGoodInEvent[evno]].pz;
    in>>fData[evno][fGoodInEvent[evno]].x;
    in>>fData[evno][fGoodInEvent[evno]].y;
    in>>fData[evno][fGoodInEvent[evno]].z;
    
    in>>tmp;
    in>>tmp;
    in>>tmp;
    
 /* cout<<evno<<" ";
  cout<<fData[evno][fGoodInEvent[evno]].lab;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].code;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].px;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].py;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].pz;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].x;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].y;
  cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].z;
  cout<<"\n";
 */ 
  fGoodInEvent[evno]++;
 }
 in.close();
 cout<<"AliGoodTracksPP::AliGoodTracksPP()  ....  Done\n";
}


const GoodTrack& AliGoodTracksPP::GetTrack(Int_t event, Int_t n) const
 {
  
  if( (event>fNevents) || (event<0))
   {
     gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Event %d",event);
   }
  if( (n>fGoodInEvent[event]) || (n<0))
   {
     gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Good TPC Track %d",n);
   }
  return fData[event][n];

 }
Commit	Line	Data
1b446896	1	#include "AliHBTReaderPPprod.h"
1b446896	2
d0c23b58	3	#include <Riostream.h>
d0c23b58	4	#include <Riostream.h>
1b446896	5	#include <TString.h>
	6	#include <TTree.h>
	7	#include <TFile.h>
	8
	9	#include <AliTPCtrack.h>
	10	#include <AliTPCParam.h>
	11	#include <AliTPCtracker.h>
	12
	13	#include "AliRun.h"
	14	#include "AliHBTRun.h"
	15	#include "AliHBTEvent.h"
	16	#include "AliHBTParticle.h"
	17	#include "AliHBTParticleCut.h"
	18
	19
	20	ClassImp(AliHBTReaderPPprod)
	21
	22	AliHBTReaderPPprod::
	23	AliHBTReaderPPprod(const Char_t* trackfilename,const Char_t* clusterfilename,
	24	const Char_t* goodtracksfilename,const Char_t* galicefilename):
	25	fTrackFileName(trackfilename),fClusterFileName(clusterfilename),
	26	fGAliceFileName(galicefilename),
	27	fGoodTPCTracksFileName(goodtracksfilename)
	28	{
	29	//constructor, only file names are set
	30	//Defaults:
	31	// trackfilename = "AliTPCtracks.root"
	32	// clusterfilename = "AliTPCclusters.root"
	33	// goodtracksfilename = "good_tracks_tpc"
	34	// galicefilename = "" - this means: Do not open gAlice file -
	35	// just leave the global pointer untached
	36
	37	fParticles = new AliHBTRun();
	38	fTracks = new AliHBTRun();
	39
	40	fTracksFile = 0x0; //files are opened during reading only
	41	fClustersFile = 0x0;
	42
	43	fIsRead = kFALSE;
	44	}
	45	/********************************************************************/
	46
	47	AliHBTReaderPPprod::~AliHBTReaderPPprod()
	48	{
	49	delete fParticles;
	50	delete fTracks;
	51	}
	52	/********************************************************************/
	53
	54	AliHBTEvent* AliHBTReaderPPprod::GetParticleEvent(Int_t n)
	55	{
	56	//returns Nth event with simulated particles
	57	if (!fIsRead) Read(fParticles,fTracks);
	58	return fParticles->GetEvent(n);
	59	}
	60	/********************************************************************/
	61	AliHBTEvent* AliHBTReaderPPprod::GetTrackEvent(Int_t n)
	62	{
	63	//returns Nth event with reconstructed tracks
	64	if (!fIsRead) Read(fParticles,fTracks);
	65	return fTracks->GetEvent(n);
	66	}
	67	/********************************************************************/
	68
69	Int_t AliHBTReaderPPprod::GetNumberOfPartEvents()
70	{
71	//returns number of events of particles
72	if (!fIsRead) Read(fParticles,fTracks);
73	return fParticles->GetNumberOfEvents();
74	}
75
76	/********************************************************************/
77	Int_t AliHBTReaderPPprod::GetNumberOfTrackEvents()
78	{
79	//returns number of events of tracks
80	if (!fIsRead) Read(fParticles,fTracks);
81	return fTracks->GetNumberOfEvents();
82	}
83	/********************************************************************/
84
85
86	Int_t AliHBTReaderPPprod::Read(AliHBTRun* particles, AliHBTRun *tracks)
87	{
88	//reads data and puts put to the particles and tracks objects
89	//reurns 0 if everything is OK
90	//
88cb7938	91	cout<<"New I/O not implemented\n";
	92	return 0;
	93
1b446896	94	Int_t i; //iterator and some temprary values
	95	Int_t Nevents;
	96	if (!particles) //check if an object is instatiated
	97	{
	98	Error("AliHBTReaderPPprod::Read"," particles object must instatiated before passing it to the reader");
	99	}
	100	if (!tracks) //check if an object is instatiated
	101	{
	102	Error("AliHBTReaderPPprod::Read"," tracks object must instatiated before passing it to the reader");
	103	}
	104	particles->Reset();//clear runs == delete all old events
	105	tracks->Reset();
	106
	107	if( (i=OpenFiles()) )
	108	{
	109	Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
	110	return i;
	111	}
	112
	113	AliGoodTracksPP *goodTPCTracks = new AliGoodTracksPP(fGoodTPCTracksFileName);
	114	if (!goodTPCTracks)
	115	{
	116	Error("AliHBTReaderPPprod::Read","Exiting due to problems with opening files. Errorcode %d",i);
	117	return 1;
	118	}
	119
	120	Nevents = 100;
	121
	122	fClustersFile->cd();
	123	AliTPCParam TPCParam= (AliTPCParam)fClustersFile->Get("75x40_100x60");
	124	if (!TPCParam)
	125	{
	126	Error("AliHBTReaderPPprod::Read","TPC parameters have not been found !\n");
	127	return 1;
	128	}
	129
	130	TObjArray *tarray = new TObjArray(5000);
	131	tarray->SetOwner();// this causes memory leak, but in some cases deleting is infinite loop
	132
	133
	134	for(Int_t currentEvent =0; currentEvent<Nevents;currentEvent++)
	135	{
	136	cout<<"Reading Event "<<currentEvent<<endl;
	137	/**************************************/
	138	/**************************************/
	139	/**************************************/
	140	fTracksFile->cd();
	141	Char_t treename[100];
	142	sprintf(treename,"TreeT_TPC_%d",currentEvent);
	143
	144	TTree *tracktree=0;
	145
	146	tracktree=(TTree*)fTracksFile->Get(treename);
	147	if (!tracktree)
	148	{
	149	Error("AliHBTReaderPPprod::Read","Can't get a tree with TPC tracks !\n");
	150	return 1;
	151	}
	152
	153	TBranch *trackbranch=tracktree->GetBranch("tracks");
	154	if (!trackbranch)
	155	{
	156	Error("AliHBTReaderPPprod::Read","Can't get a branch with TPC tracks !\n");
	157	return 2;
158	}
159	Int_t NTPCtracks=(Int_t)tracktree->GetEntries();
160	cout<<"Found "<<NTPCtracks<<" TPC tracks.\n";
161	//Copy tracks to array
162
163	AliTPCtrack *iotrack=0;
164
165	fClustersFile->cd();
c630aafd	166	printf("This method is not converted to the NewIO !\n"); //I.B.
	167	return 1; //I.B.
	168	AliTPCtracker *tracker = new AliTPCtracker(TPCParam); //I.B.
	169	//AliTPCtracker *tracker = new AliTPCtracker(TPCParam,currentEvent,"");
1b446896	170	if (!tracker)
	171	{
	172	Error("AliHBTReaderPPprod::Read","Can't get a tracker !\n");
	173	return 3;
	174	}
c630aafd	175	tracker->LoadClusters(0);//I.Belikov, "0" should be a pointer to a tree
1b446896	176
	177	for (i=0; i<NTPCtracks; i++)
	178	{
	179	iotrack=new AliTPCtrack;
	180	trackbranch->SetAddress(&iotrack);
	181	tracktree->GetEvent(i);
	182	tracker->CookLabel(iotrack,0.1);
	183	tarray->AddLast(iotrack);
	184	}
	185
	186
	187	fTracksFile->Delete(treename);//delete tree from memmory (and leave untached on disk)- we do not need it any more
	188	fTracksFile->Delete("tracks");
	189
	190	delete tracker;
	191
	192	tracker = 0x0;
	193	trackbranch = 0x0;
	194	tracktree = 0x0;
	195
	196	Int_t & ngood = goodTPCTracks->fGoodInEvent[currentEvent];
	197
	198	Double_t xk;
	199	Double_t par[5];
	200	Float_t phi, lam, pt;
	201	Int_t label;
	202	Bool_t found;
	203
	204	for (i=0; i<ngood; i++)
	205	{
	206	const struct GoodTrack & gt = goodTPCTracks->GetTrack(currentEvent,i);
	207
	208	if(Pass(gt.code)) continue;
	209
	210	label = gt.lab;
	211	found = kFALSE; //guard in case we don't find track with such a label
	212	for (Int_t j=0;j<NTPCtracks;j++)
	213	{
	214	iotrack = (AliTPCtrack*)tarray->At(j);
	215	if (iotrack->GetLabel() == label)
	216	{
	217	found = kTRUE;
	218	break;
	219	}
	220	}
	221	if(!found)
	222	{
	223	Warning("Read",
	224	"Sth is going wrong with tracks - there is no TPC track corresponding to goodtrack.\nGood tack label %d",label);
	225	continue; //put comunicate on the screen and continue loop
	226	}
	227
	228	Double_t mass = TDatabasePDG::Instance()->GetParticle(gt.code)->Mass();
	229	Double_t pEtot = TMath::Sqrt(gt.pxgt.px + gt.pygt.py + gt.pzgt.pz + massmass);
	230
88cb7938	231	AliHBTParticle* part = new AliHBTParticle(gt.code,i, gt.px, gt.py, gt.pz, pEtot, gt.x, gt.y, gt.z, 0.0);
1b446896	232	if(Pass(part)) continue;
	233
	234
	235	iotrack->PropagateTo(gt.x);
	236	iotrack->GetExternalParameters(xk,par);
	237	phi=TMath::ASin(par[2]) + iotrack->GetAlpha();
	238	if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
	239	if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
	240	lam=par[3];
	241	pt=1.0/TMath::Abs(par[4]);
	242
	243	Double_t tpx = pt * TMath::Cos(phi); //track x coordinate of momentum
	244	Double_t tpy = pt * TMath::Sin(phi); //track x coordinate of momentum
	245	Double_t tpz = pt * lam;
	246
	247	Double_t tEtot = TMath::Sqrt( tpxtpx + tpytpy + tpztpz + massmass);
	248
88cb7938	249	AliHBTParticle* track = new AliHBTParticle(gt.code,i, tpx, tpy , tpz, tEtot, 0., 0., 0., 0.);
1b446896	250	if(Pass(track)) continue;
	251
	252	particles->AddParticle(currentEvent,part);
	253	tracks->AddParticle(currentEvent,track);
	254
	255	}
	256	tarray->Clear();
	257	/**************************************/
	258	/**************************************/
	259	/**************************************/
	260	}
	261
	262	CloseFiles();
	263	delete tarray;
	264	delete goodTPCTracks;
	265	fIsRead = kTRUE;
	266	return 0;
	267	}
	268
	269	/********************************************************************/
	270	Int_t AliHBTReaderPPprod::OpenFiles()
	271	{
	272
	273	fTracksFile = 0;
	274	fTracksFile=TFile::Open("AliTPCtracks.root");
	275	if (!fTracksFile->IsOpen())
	276	{
	277	Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCtracks.root");
	278	return 1;
	279	}
	280
	281	fClustersFile = 0;
	282
	283	fClustersFile=TFile::Open("AliTPCclusters.root");
	284	if (!fClustersFile->IsOpen())
	285	{
	286	Error("AliHBTReaderPPprod::OpenFiles","Can't open AliTPCclusters.root");
	287	return 2;
	288	}
	289
	290
	291
	292	return 0;
	293	}
	294
	295
	296
	297	/********************************************************************/
	298
	299	void AliHBTReaderPPprod::CloseFiles()
	300	{
	301	fTracksFile->Close();
	302	fClustersFile->Close();
	303	}
	304
	305	/********************************************************************/
	306
	307	/********************************************************************/
	308	/********************************************************************/
	309	/********************************************************************/
	310
	311
	312	AliGoodTracksPP::~AliGoodTracksPP()
	313	{
314	delete [] fGoodInEvent;
315	for (Int_t i = 0;i<fNevents;i++)
316	delete [] fData[i];
317	delete [] fData;
318	}
319	/********************************************************************/
320	AliGoodTracksPP::AliGoodTracksPP(const TString& infilename)
321	{
322
323	fNevents = 100;
324	ifstream in(infilename.Data());
325
326	if(!in)
327	{
328	cerr<<"Can not open file with Good TPC Tracks named:"<<infilename.Data()<<endl;
329	delete this;
330	return;
331	}
332
333
334	fGoodInEvent = new Int_t[fNevents];
335	fData = new struct GoodTrack* [fNevents];
336
337	Int_t i;
338	for( i = 0;i<fNevents;i++)
339	{
340	fGoodInEvent[i] =0;
341	fData[i] = new struct GoodTrack[500];
342	}
343	Float_t tmp;
344	Int_t evno;
345	while(in>>evno)
346	{
347	if(fGoodInEvent[evno]>=500)
348	{
349	cerr<<"AliGoodTracksPP::AliGoodTracksPP() : Not enough place in the array\n";
350	continue;
351	}
352	in>>fData[evno][fGoodInEvent[evno]].lab;
353	in>>fData[evno][fGoodInEvent[evno]].code;
354	in>>fData[evno][fGoodInEvent[evno]].px;
355	in>>fData[evno][fGoodInEvent[evno]].py;
356	in>>fData[evno][fGoodInEvent[evno]].pz;
357	in>>fData[evno][fGoodInEvent[evno]].x;
358	in>>fData[evno][fGoodInEvent[evno]].y;
359	in>>fData[evno][fGoodInEvent[evno]].z;
360
361	in>>tmp;
362	in>>tmp;
363	in>>tmp;
364
365	/* cout<<evno<<" ";
366	cout<<fData[evno][fGoodInEvent[evno]].lab;
367	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].code;
368	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].px;
369	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].py;
370	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].pz;
371	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].x;
372	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].y;
373	cout<<" ";cout<<fData[evno][fGoodInEvent[evno]].z;
374	cout<<"\n";
375	*/
376	fGoodInEvent[evno]++;
377	}
378	in.close();
379	cout<<"AliGoodTracksPP::AliGoodTracksPP() .... Done\n";
380	}
381
382
383
384	const GoodTrack& AliGoodTracksPP::GetTrack(Int_t event, Int_t n) const
385	{
386
387	if( (event>fNevents) \|\| (event<0))
388	{
389	gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Event %d",event);
390	}
391	if( (n>fGoodInEvent[event]) \|\| (n<0))
392	{
393	gAlice->Fatal("AliGoodTracksPP::GetTrack","No such Good TPC Track %d",n);
394	}
395	return fData[event][n];
396
397	}