[u/mrichter/AliRoot.git] / PHOS / AliPHOSTracker.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/
/* $Id$ */

/* History of cvs commits:
 *
 * $Log$
 * Revision 1.6  2007/08/03 14:41:37  cvetan
 * Missing header files
 *
 * Revision 1.5  2007/08/03 13:52:16  kharlov
 * Working skeleton of matching the ESD tracks and ESD clusters (Iouri Belikov)
 *
 */

#include <TClonesArray.h>
#include <TMath.h>

#include <AliLog.h>
#include "AliPHOSTracker.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliESDEvent.h"
#include "AliPHOSQualAssDataMaker.h" 
#include "AliPHOSGetter.h"
#include "AliESDtrack.h"
#include "AliPHOSTrackSegmentMakerv1.h"
#include "AliPHOSPIDv1.h"

//-------------------------------------------------------------------------
//                          PHOS tracker.
// Matches ESD tracks with the PHOS and makes the PID.  
//
//-------------------------------------------------------------------------

ClassImp(AliPHOSTracker)

Bool_t AliPHOSTracker::fgDebug = kFALSE ;  


// ***** Some geometrical constants (used in PropagateBack) 

const Double_t kR=460.+ 9;  // Radial coord. of the centre of EMC module (cm)

const Double_t kAlpha=20.*TMath::Pi()/180.;     // Segmentation angle (rad)
const Double_t kYmax=kR*TMath::Tan(0.5*kAlpha); // Maximal possible y-coord.(cm)
const Double_t kZmax=65.; // Approximately: the maximal possible z-coord.(cm)


//____________________________________________________________________________
AliPHOSTracker::AliPHOSTracker(): 
  AliTracker(), 
  fRunLoader(0), 
  fTSM(0x0), 
  fPID(0x0) 
{
  //--------------------------------------------------------------------
  // The default constructor
  //--------------------------------------------------------------------
  for (Int_t i=0; i<5; i++) 
      fModules[i]=new TClonesArray("AliPHOSEmcRecPoint",777);
  
  fTSM = new AliPHOSTrackSegmentMakerv1("to be set", "to be set");
  fTSM->GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ; 
  fPID = new AliPHOSPIDv1("to be set", "to be set");
  fPID->GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ;    
}

//____________________________________________________________________________
AliPHOSTracker::~AliPHOSTracker() 
{
  //--------------------------------------------------------------------
  // The destructor
  //--------------------------------------------------------------------
  for (Int_t i=0; i<5; i++) {
      (fModules[i])->Delete();
      delete fModules[i];
  }
  delete fTSM ;
  delete fPID ; 
}

//____________________________________________________________________________
Int_t AliPHOSTracker::LoadClusters(TTree *cTree) {
  //--------------------------------------------------------------------
  // This function loads the PHOS clusters
  //--------------------------------------------------------------------
  TObjArray *arr=NULL;
  TBranch *branch=cTree->GetBranch("PHOSEmcRP");
  if (branch==0) {
    AliError("No branch with the EMC clusters found !");
    return 1;
  }
  branch->SetAddress(&arr);

  Int_t nclusters=0;
  Int_t nentr=(Int_t)branch->GetEntries();
  for (Int_t i=0; i<nentr; i++) {
    if (!branch->GetEvent(i)) continue;
    Int_t ncl=arr->GetEntriesFast();
    while (ncl--) {
      AliPHOSEmcRecPoint *cl=(AliPHOSEmcRecPoint*)arr->UncheckedAt(ncl);

      Int_t m=cl->GetPHOSMod();
      if ((m<1)||(m>5)) {
         AliError("Wrong module index !");
         return 1;
      }

      // Here is how the alignment is treated
      if (!cl->Misalign()) AliWarning("Can't misalign this cluster !");

      cl->SetBit(14,kFALSE); // The clusters are not yet attached to any track

      TClonesArray &module=*fModules[m-1];
      Int_t idx=module.GetEntriesFast();
      new (module[idx]) AliPHOSEmcRecPoint(*cl); 

      nclusters++;

    }
  }  

  Info("LoadClusters","Number of loaded clusters: %d",nclusters);

  return 0;
}

//____________________________________________________________________________
Int_t AliPHOSTracker::PropagateBack(AliESDEvent *esd) {
  //--------------------------------------------------------------------
  // Called by AliReconstruction 
  // Performs the track matching with the PHOS modules
  // Makes the PID
  //--------------------------------------------------------------------

  // The following old function is a bad function: it uses RunLoader ;(
  PropagateBackOld(esd);   


  Int_t nt=esd->GetNumberOfTracks();

  // *** Select and sort the ESD track in accordance with their quality
  Double_t *quality=new Double_t[nt];
  Int_t *index=new Int_t[nt];  
  for (Int_t i=0; i<nt; i++) {
     AliESDtrack *esdTrack=esd->GetTrack(i);
     quality[i] = esdTrack->GetSigmaY2() + esdTrack->GetSigmaZ2();
  }
  TMath::Sort(nt,quality,index,kFALSE);


  // *** Start the matching
  Double_t bz=GetBz(); 
  Int_t matched=0;
  for (Int_t i=0; i<nt; i++) {
     AliESDtrack *esdTrack=esd->GetTrack(index[i]);

     // Skip the tracks having "wrong" status (has to be checked/tuned)
     ULong_t status = esdTrack->GetStatus();
     if ((status & AliESDtrack::kTRDout)   == 0) continue;
     if ((status & AliESDtrack::kTRDrefit) == 1) continue;

     AliExternalTrackParam t(*esdTrack);

     Int_t isec=Int_t(t.GetAlpha()/kAlpha);
     Int_t imod=-isec-2; // PHOS module

     Double_t y;                       // Some tracks do not reach the PHOS
     if (!t.GetYAt(kR,bz,y)) continue; //    because of the bending

     Double_t z; t.GetZAt(kR,bz,z);   
     if (TMath::Abs(z) > kZmax) continue; // Some tracks miss the PHOS in Z
 
     Bool_t ok=kTRUE;
     while (TMath::Abs(y) > kYmax) {   // Find the matching module
        Double_t alp=t.GetAlpha();
        if (y > kYmax) {
	  if (!t.Rotate(alp+kAlpha)) {ok=kFALSE; break;}
          imod--;
        } else if (y < -kYmax) {
	  if (!t.Rotate(alp-kAlpha)) {ok=kFALSE; break;}
          imod++;
        }
        if (!t.GetYAt(kR,bz,y)) {ok=kFALSE; break;}
     }
     if (!ok) continue; // Track rotation failed
 
  
     if ((imod<0)||(imod>4)) continue; // Some tracks miss the PHOS in azimuth

     //t.CorrectForMaterial(...); // Correct for the TOF material, if needed
     t.PropagateTo(kR,bz);        // Propagate to the matching module


    // *** Search for the "best" cluster (can be improved)
     TClonesArray &cArray=*fModules[imod];
     Int_t ncl=cArray.GetEntriesFast();
     AliPHOSEmcRecPoint *bestCluster=0;            // The "best" cluster
     Double_t maxd2=400; // (cm^2)
     for (Int_t i=0; i<ncl; i++) {
       AliPHOSEmcRecPoint *c=(AliPHOSEmcRecPoint *)cArray.UncheckedAt(i);

       if (c->TestBit(14)) continue; // This clusters is "used"

       Double_t dy = t.GetY() - c->GetY(), dz = t.GetZ() - c->GetZ();
       Double_t d2 = dy*dy + dz*dz;
       if (d2 < maxd2) {
	  maxd2=d2;
          bestCluster=c;
       }
     }

     if (!bestCluster) continue;   // No reasonable matching found 

     bestCluster->SetBit(14,kTRUE); // This clusters is now attached to a track

     matched++;

     // *** Now, do the PID with the "bestCluster"
     // and add the corresponding info to the ESD track pointed by "esdTrack"  

     /*
     printf("%e %e %e %e\n",t.GetSign(), t.GetX() - bestCluster->GetX(),
	                                 t.GetY() - bestCluster->GetY(),
	                                 t.GetZ() - bestCluster->GetZ());
     */
  }
    
  Info("PropagateBack","Number of matched tracks: %d",matched);

  delete[] quality;
  delete[] index;

  return 0;
}

//____________________________________________________________________________
AliCluster *AliPHOSTracker::GetCluster(Int_t index) const {
  //--------------------------------------------------------------------
  // Returns the pointer to a given cluster
  //--------------------------------------------------------------------
  Int_t m=(index & 0xf0000000) >> 28;  // Module number
  Int_t i=(index & 0x0fffffff) >> 00;  // Index within the module
  
  return (AliCluster*)(fModules[m])->UncheckedAt(i);
}

//____________________________________________________________________________
void AliPHOSTracker::UnloadClusters() {
  //--------------------------------------------------------------------
  // This function unloads the PHOS clusters
  //--------------------------------------------------------------------
  for (Int_t i=0; i<5; i++) (fModules[i])->Delete();
}


// **** The following are bad functions:  they use RunLoader ;(
// **** To be rewritten.

#include "AliPHOSTrackSegmentMakerv1.h"
#include "AliPHOSTrackSegmentMakerv2.h"
#include "AliPHOSPIDv1.h"
#include "AliRunLoader.h"

//____________________________________________________________________________
Int_t AliPHOSTracker::PropagateBackOld(AliESDEvent *esd) {
  // Bad function: it uses RunLoader ;(  
  // Creates the tracksegments and Recparticles
  // Makes the PID
  
  AliPHOSGetter * gime = AliPHOSGetter::Instance() ;  
  Int_t eventNumber = gime->PhosLoader()->GetRunLoader()->GetEventNumber() ;

  TString headerFile(gime->PhosLoader()->GetRunLoader()->GetFileName()) ; 
  TString branchName(gime->PhosLoader()->GetRunLoader()->GetEventFolder()->GetName()) ;  

  // do current event; the loop over events is done by AliReconstruction::Run()

  fTSM->SetTitle(headerFile) ; 
  fTSM->SetEventFolderName(branchName) ;
  fTSM->SetESD(esd) ; 
  fTSM->SetEventRange(eventNumber, eventNumber) ; 
  if ( Debug() ) 
   fTSM->ExecuteTask("deb all") ;
  else 
    fTSM->ExecuteTask("") ;
  
  fTSM->GetQualAssDataMaker()->SetData(gime->TrackSegments()) ; 
  fTSM->GetQualAssDataMaker()->Exec(AliQualAss::kTRACKSEGMENTS) ; 

  fPID->SetTitle(headerFile) ; 
  fPID->SetEventFolderName(branchName) ;
  fPID->SetESD(esd) ; 
  fPID->SetEventRange(eventNumber, eventNumber) ; 
  if ( Debug() ) 
   fPID->ExecuteTask("deb all") ;
  else 
    fPID->ExecuteTask("") ;

  fPID->GetQualAssDataMaker()->SetData(gime->RecParticles()) ; 
  fPID->GetQualAssDataMaker()->Exec(AliQualAss::kRECPARTICLES) ; 
  
  if ( eventNumber == gime->MaxEvent()-1 ) {
	fTSM->GetQualAssDataMaker()->Finish(AliQualAss::kTRACKSEGMENTS) ; 
	fPID->GetQualAssDataMaker()->Finish(AliQualAss::kRECPARTICLES) ; 
  }
	
  return 0;
}

//____________________________________________________________________________
AliPHOSTracker::AliPHOSTracker(AliRunLoader *l) : 
  AliTracker(), 
  fRunLoader(0), 
  fTSM(0x0), 
  fPID(0x0) 
{
  //--------------------------------------------------------------------
  // Bad constructor:  uses RunLoader ;(
  //--------------------------------------------------------------------
  for (Int_t i=0; i<5; i++) 
      fModules[i]=new TClonesArray("AliPHOSEmcRecPoint",777);
  fTSM = new AliPHOSTrackSegmentMakerv1("to be set", "to be set");
  fPID = new AliPHOSPIDv1("to be set", "to be set");
}
Commit	Line	Data
04e92dc8	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	/* $Id$ */
	16
	17	/* History of cvs commits:
	18	*
	19	* $Log$
ddd1a39c	20	* Revision 1.6 2007/08/03 14:41:37 cvetan
	21	* Missing header files
	22	*
1d0c181d	23	* Revision 1.5 2007/08/03 13:52:16 kharlov
	24	* Working skeleton of matching the ESD tracks and ESD clusters (Iouri Belikov)
	25	*
04e92dc8	26	*/
	27
	28	#include <TClonesArray.h>
1d0c181d	29	#include <TMath.h>
04e92dc8	30
04e92dc8	31	#include <AliLog.h>
23904d16	32	#include "AliPHOSTracker.h"
04e92dc8	33	#include "AliPHOSEmcRecPoint.h"
af885e0f	34	#include "AliESDEvent.h"
ddd1a39c	35	#include "AliPHOSQualAssDataMaker.h"
ddd1a39c	36	#include "AliPHOSGetter.h"
1d0c181d	37	#include "AliESDtrack.h"
ddd1a39c	38	#include "AliPHOSTrackSegmentMakerv1.h"
ddd1a39c	39	#include "AliPHOSPIDv1.h"
23904d16	40
	41	//-------------------------------------------------------------------------
	42	// PHOS tracker.
	43	// Matches ESD tracks with the PHOS and makes the PID.
04e92dc8	44	//
23904d16	45	//-------------------------------------------------------------------------
	46
	47	ClassImp(AliPHOSTracker)
	48
04e92dc8	49	Bool_t AliPHOSTracker::fgDebug = kFALSE ;
	50
	51
	52	// ***** Some geometrical constants (used in PropagateBack)
	53
	54	const Double_t kR=460.+ 9; // Radial coord. of the centre of EMC module (cm)
	55
	56	const Double_t kAlpha=20.*TMath::Pi()/180.; // Segmentation angle (rad)
	57	const Double_t kYmax=kRTMath::Tan(0.5kAlpha); // Maximal possible y-coord.(cm)
	58	const Double_t kZmax=65.; // Approximately: the maximal possible z-coord.(cm)
	59
	60
	61
ddd1a39c	62	//____________________________________________________________________________
	63	AliPHOSTracker::AliPHOSTracker():
	64	AliTracker(),
	65	fRunLoader(0),
	66	fTSM(0x0),
	67	fPID(0x0)
	68	{
04e92dc8	69	//--------------------------------------------------------------------
	70	// The default constructor
	71	//--------------------------------------------------------------------
	72	for (Int_t i=0; i<5; i++)
	73	fModules[i]=new TClonesArray("AliPHOSEmcRecPoint",777);
ddd1a39c	74
	75	fTSM = new AliPHOSTrackSegmentMakerv1("to be set", "to be set");
	76	fTSM->GetQualAssDataMaker()->Init(AliQualAss::kTRACKSEGMENTS) ;
	77	fPID = new AliPHOSPIDv1("to be set", "to be set");
	78	fPID->GetQualAssDataMaker()->Init(AliQualAss::kRECPARTICLES) ;
04e92dc8	79	}
04e92dc8	80
ddd1a39c	81	//____________________________________________________________________________
	82	AliPHOSTracker::~AliPHOSTracker()
	83	{
04e92dc8	84	//--------------------------------------------------------------------
	85	// The destructor
	86	//--------------------------------------------------------------------
	87	for (Int_t i=0; i<5; i++) {
	88	(fModules[i])->Delete();
	89	delete fModules[i];
	90	}
ddd1a39c	91	delete fTSM ;
ddd1a39c	92	delete fPID ;
04e92dc8	93	}
04e92dc8	94
ddd1a39c	95	//____________________________________________________________________________
04e92dc8	96	Int_t AliPHOSTracker::LoadClusters(TTree *cTree) {
	97	//--------------------------------------------------------------------
	98	// This function loads the PHOS clusters
	99	//--------------------------------------------------------------------
	100	TObjArray *arr=NULL;
	101	TBranch *branch=cTree->GetBranch("PHOSEmcRP");
	102	if (branch==0) {
	103	AliError("No branch with the EMC clusters found !");
	104	return 1;
	105	}
	106	branch->SetAddress(&arr);
	107
	108	Int_t nclusters=0;
	109	Int_t nentr=(Int_t)branch->GetEntries();
	110	for (Int_t i=0; i<nentr; i++) {
	111	if (!branch->GetEvent(i)) continue;
	112	Int_t ncl=arr->GetEntriesFast();
	113	while (ncl--) {
	114	AliPHOSEmcRecPoint cl=(AliPHOSEmcRecPoint)arr->UncheckedAt(ncl);
	115
	116	Int_t m=cl->GetPHOSMod();
	117	if ((m<1)\|\|(m>5)) {
	118	AliError("Wrong module index !");
	119	return 1;
	120	}
	121
	122	// Here is how the alignment is treated
	123	if (!cl->Misalign()) AliWarning("Can't misalign this cluster !");
	124
	125	cl->SetBit(14,kFALSE); // The clusters are not yet attached to any track
	126
	127	TClonesArray &module=*fModules[m-1];
	128	Int_t idx=module.GetEntriesFast();
	129	new (module[idx]) AliPHOSEmcRecPoint(*cl);
	130
	131	nclusters++;
	132
	133	}
	134	}
	135
	136	Info("LoadClusters","Number of loaded clusters: %d",nclusters);
	137
	138	return 0;
	139	}
	140
ddd1a39c	141	//____________________________________________________________________________
af885e0f	142	Int_t AliPHOSTracker::PropagateBack(AliESDEvent *esd) {
04e92dc8	143	//--------------------------------------------------------------------
23904d16	144	// Called by AliReconstruction
04e92dc8	145	// Performs the track matching with the PHOS modules
	146	// Makes the PID
	147	//--------------------------------------------------------------------
	148
	149	// The following old function is a bad function: it uses RunLoader ;(
	150	PropagateBackOld(esd);
	151
	152
	153	Int_t nt=esd->GetNumberOfTracks();
	154
	155	// *** Select and sort the ESD track in accordance with their quality
	156	Double_t *quality=new Double_t[nt];
	157	Int_t *index=new Int_t[nt];
	158	for (Int_t i=0; i<nt; i++) {
	159	AliESDtrack *esdTrack=esd->GetTrack(i);
	160	quality[i] = esdTrack->GetSigmaY2() + esdTrack->GetSigmaZ2();
	161	}
	162	TMath::Sort(nt,quality,index,kFALSE);
	163
	164
	165	// *** Start the matching
	166	Double_t bz=GetBz();
	167	Int_t matched=0;
	168	for (Int_t i=0; i<nt; i++) {
	169	AliESDtrack *esdTrack=esd->GetTrack(index[i]);
	170
	171	// Skip the tracks having "wrong" status (has to be checked/tuned)
	172	ULong_t status = esdTrack->GetStatus();
	173	if ((status & AliESDtrack::kTRDout) == 0) continue;
	174	if ((status & AliESDtrack::kTRDrefit) == 1) continue;
	175
	176	AliExternalTrackParam t(*esdTrack);
	177
	178	Int_t isec=Int_t(t.GetAlpha()/kAlpha);
	179	Int_t imod=-isec-2; // PHOS module
	180
	181	Double_t y; // Some tracks do not reach the PHOS
	182	if (!t.GetYAt(kR,bz,y)) continue; // because of the bending
	183
	184	Double_t z; t.GetZAt(kR,bz,z);
	185	if (TMath::Abs(z) > kZmax) continue; // Some tracks miss the PHOS in Z
	186
	187	Bool_t ok=kTRUE;
	188	while (TMath::Abs(y) > kYmax) { // Find the matching module
	189	Double_t alp=t.GetAlpha();
	190	if (y > kYmax) {
	191	if (!t.Rotate(alp+kAlpha)) {ok=kFALSE; break;}
	192	imod--;
	193	} else if (y < -kYmax) {
	194	if (!t.Rotate(alp-kAlpha)) {ok=kFALSE; break;}
	195	imod++;
	196	}
	197	if (!t.GetYAt(kR,bz,y)) {ok=kFALSE; break;}
	198	}
	199	if (!ok) continue; // Track rotation failed
	200
	201
	202	if ((imod<0)\|\|(imod>4)) continue; // Some tracks miss the PHOS in azimuth
	203
	204	//t.CorrectForMaterial(...); // Correct for the TOF material, if needed
	205	t.PropagateTo(kR,bz); // Propagate to the matching module
	206
	207
	208	// *** Search for the "best" cluster (can be improved)
209	TClonesArray &cArray=*fModules[imod];
210	Int_t ncl=cArray.GetEntriesFast();
211	AliPHOSEmcRecPoint *bestCluster=0; // The "best" cluster
212	Double_t maxd2=400; // (cm^2)
213	for (Int_t i=0; i<ncl; i++) {
214	AliPHOSEmcRecPoint c=(AliPHOSEmcRecPoint )cArray.UncheckedAt(i);
215
216	if (c->TestBit(14)) continue; // This clusters is "used"
217
218	Double_t dy = t.GetY() - c->GetY(), dz = t.GetZ() - c->GetZ();
219	Double_t d2 = dydy + dzdz;
220	if (d2 < maxd2) {
221	maxd2=d2;
222	bestCluster=c;
223	}
224	}
225
226	if (!bestCluster) continue; // No reasonable matching found
227
228	bestCluster->SetBit(14,kTRUE); // This clusters is now attached to a track
229
230	matched++;
231
232	// *** Now, do the PID with the "bestCluster"
233	// and add the corresponding info to the ESD track pointed by "esdTrack"
234
235	/*
236	printf("%e %e %e %e\n",t.GetSign(), t.GetX() - bestCluster->GetX(),
237	t.GetY() - bestCluster->GetY(),
238	t.GetZ() - bestCluster->GetZ());
239	*/
240	}
241
242	Info("PropagateBack","Number of matched tracks: %d",matched);
243
244	delete[] quality;
245	delete[] index;
246
247	return 0;
248	}
249
ddd1a39c	250	//____________________________________________________________________________
04e92dc8	251	AliCluster *AliPHOSTracker::GetCluster(Int_t index) const {
	252	//--------------------------------------------------------------------
	253	// Returns the pointer to a given cluster
	254	//--------------------------------------------------------------------
	255	Int_t m=(index & 0xf0000000) >> 28; // Module number
	256	Int_t i=(index & 0x0fffffff) >> 00; // Index within the module
	257
	258	return (AliCluster*)(fModules[m])->UncheckedAt(i);
	259	}
	260
ddd1a39c	261	//____________________________________________________________________________
04e92dc8	262	void AliPHOSTracker::UnloadClusters() {
	263	//--------------------------------------------------------------------
	264	// This function unloads the PHOS clusters
	265	//--------------------------------------------------------------------
	266	for (Int_t i=0; i<5; i++) (fModules[i])->Delete();
	267	}
	268
	269
	270
	271	// **** The following are bad functions: they use RunLoader ;(
	272	// **** To be rewritten.
	273
	274	#include "AliPHOSTrackSegmentMakerv1.h"
	275	#include "AliPHOSTrackSegmentMakerv2.h"
	276	#include "AliPHOSPIDv1.h"
	277	#include "AliRunLoader.h"
	278
ddd1a39c	279	//____________________________________________________________________________
04e92dc8	280	Int_t AliPHOSTracker::PropagateBackOld(AliESDEvent *esd) {
04e92dc8	281	// Bad function: it uses RunLoader ;(
23904d16	282	// Creates the tracksegments and Recparticles
	283	// Makes the PID
	284
ddd1a39c	285	AliPHOSGetter * gime = AliPHOSGetter::Instance() ;
ddd1a39c	286	Int_t eventNumber = gime->PhosLoader()->GetRunLoader()->GetEventNumber() ;
4b598bb1	287
ddd1a39c	288	TString headerFile(gime->PhosLoader()->GetRunLoader()->GetFileName()) ;
ddd1a39c	289	TString branchName(gime->PhosLoader()->GetRunLoader()->GetEventFolder()->GetName()) ;
23904d16	290
23904d16	291	// do current event; the loop over events is done by AliReconstruction::Run()
ddd1a39c	292
	293	fTSM->SetTitle(headerFile) ;
	294	fTSM->SetEventFolderName(branchName) ;
	295	fTSM->SetESD(esd) ;
	296	fTSM->SetEventRange(eventNumber, eventNumber) ;
	297	if ( Debug() )
	298	fTSM->ExecuteTask("deb all") ;
	299	else
	300	fTSM->ExecuteTask("") ;
	301
	302	fTSM->GetQualAssDataMaker()->SetData(gime->TrackSegments()) ;
	303	fTSM->GetQualAssDataMaker()->Exec(AliQualAss::kTRACKSEGMENTS) ;
	304
	305	fPID->SetTitle(headerFile) ;
	306	fPID->SetEventFolderName(branchName) ;
	307	fPID->SetESD(esd) ;
	308	fPID->SetEventRange(eventNumber, eventNumber) ;
	309	if ( Debug() )
	310	fPID->ExecuteTask("deb all") ;
	311	else
	312	fPID->ExecuteTask("") ;
	313
	314	fPID->GetQualAssDataMaker()->SetData(gime->RecParticles()) ;
	315	fPID->GetQualAssDataMaker()->Exec(AliQualAss::kRECPARTICLES) ;
23904d16	316
ddd1a39c	317	if ( eventNumber == gime->MaxEvent()-1 ) {
	318	fTSM->GetQualAssDataMaker()->Finish(AliQualAss::kTRACKSEGMENTS) ;
	319	fPID->GetQualAssDataMaker()->Finish(AliQualAss::kRECPARTICLES) ;
	320	}
	321
23904d16	322	return 0;
23904d16	323	}
04e92dc8	324
ddd1a39c	325	//____________________________________________________________________________
	326	AliPHOSTracker::AliPHOSTracker(AliRunLoader *l) :
	327	AliTracker(),
	328	fRunLoader(0),
	329	fTSM(0x0),
	330	fPID(0x0)
	331	{
04e92dc8	332	//--------------------------------------------------------------------
	333	// Bad constructor: uses RunLoader ;(
	334	//--------------------------------------------------------------------
	335	for (Int_t i=0; i<5; i++)
	336	fModules[i]=new TClonesArray("AliPHOSEmcRecPoint",777);
ddd1a39c	337	fTSM = new AliPHOSTrackSegmentMakerv1("to be set", "to be set");
ddd1a39c	338	fPID = new AliPHOSPIDv1("to be set", "to be set");
04e92dc8	339	}
04e92dc8	340