#include "AliEMCALClusterizerv1.h"
#include "AliEMCALPIDv1.h"
#include "AliEMCALGetter.h"
+#include "AliEMCALTracker.h"
#include "AliRawReaderFile.h"
ClassImp(AliEMCALReconstructor)
Int_t eventNumber = runLoader->GetEventNumber() ;
- TString headerFile(runLoader->GetFileName()) ;
- TString branchName(runLoader->GetEventFolder()->GetName()) ;
-
- AliEMCALPIDv1 pid(headerFile, branchName);
-
-
- // do current event; the loop over events is done by AliReconstruction::Run()
- pid.SetEventRange(eventNumber, eventNumber) ;
- if ( Debug() )
- pid.ExecuteTask("deb all") ;
- else
- pid.ExecuteTask("") ;
-
// Creates AliESDtrack from AliEMCALRecParticles
AliEMCALGetter::Instance()->Event(eventNumber, "P") ;
TClonesArray *recParticles = AliEMCALGetter::Instance()->RecParticles();
delete et;
}
}
+
+AliTracker* AliEMCALReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+// creates the EMCAL tracker
+ if (!runLoader) return NULL;
+ return new AliEMCALTracker(runLoader);
+}
virtual ~AliEMCALReconstructor() ; //dtor
Bool_t Debug() const { return fDebug ; }
- virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
+ AliTracker *CreateTracker(AliRunLoader* runLoader) const;
+ virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
virtual void Reconstruct(AliRunLoader* runLoader) const ;
virtual void Reconstruct(AliRunLoader* runLoader, AliRawReaderFile * rawreader) const ;
--- /dev/null
+#include "AliEMCALTracker.h"
+#include "AliEMCALPIDv1.h"
+#include "AliRunLoader.h"
+#include "AliESD.h"
+
+//-------------------------------------------------------------------------
+// EMCAL tracker.
+// Matches ESD tracks with the EMCAL and makes the PID.
+// Currently, has only one function implemented : PropagateBack(AliESD*)
+//-------------------------------------------------------------------------
+
+ClassImp(AliEMCALTracker)
+
+Bool_t AliEMCALTracker::fgDebug = kFALSE ;
+
+Int_t AliEMCALTracker::PropagateBack(AliESD *esd) {
+ // Makes the Particle Identification
+
+ esd=0; // This is to avoid a compilation warning.
+ // This pointer is reserved for future needs
+
+ Int_t eventNumber = fRunLoader->GetEventNumber() ;
+
+ TString headerFile(fRunLoader->GetFileName()) ;
+ TString branchName(fRunLoader->GetEventFolder()->GetName()) ;
+
+ AliEMCALPIDv1 pid(headerFile, branchName);
+
+ // do current event; the loop over events is done by AliReconstruction::Run()
+ pid.SetEventRange(eventNumber, eventNumber) ;
+ if ( Debug() )
+ pid.ExecuteTask("deb all") ;
+ else
+ pid.ExecuteTask("") ;
+
+ return 0;
+}
--- /dev/null
+#ifndef AliEMCALTracker_h
+#define AliEMCALTracker_h
+
+//-------------------------------------------------------------------------
+// EMCAL tracker.
+// Matches ESD tracks with the EMCAL and makes the PID.
+// Currently, has only one function implemented : PropagateBack(AliESD*).
+//-------------------------------------------------------------------------
+
+#include <AliTracker.h>
+#include <AliLog.h>
+
+class AliCluster;
+class AliESD;
+class TTree;
+class AliRunLoader;
+
+class AliEMCALTracker : public AliTracker
+{
+public:
+ AliEMCALTracker():AliTracker() {fRunLoader=0;}
+ AliEMCALTracker(AliRunLoader *loader):AliTracker() {fRunLoader=loader;}
+ virtual ~AliEMCALTracker() {AliDebug(1,"Start.");}
+
+ Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
+ Int_t RefitInward(AliESD *) {AliDebug(1,"Start.");return 0;}
+ void UnloadClusters() {AliDebug(1,"Start.");}
+ AliCluster *GetCluster(Int_t ) const {AliDebug(1,"Start.");return 0;}
+ Int_t PropagateBack(AliESD *);
+ Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
+
+ static void SetDebug() { fgDebug = kTRUE ; }
+ static void ResetDebug() { fgDebug = kFALSE ; }
+ static Bool_t Debug() { return fgDebug ; }
+
+private:
+ static Bool_t fgDebug ; //! Verbosity controller
+ AliRunLoader *fRunLoader; //! Pointer to the run loader
+ ClassDef(AliEMCALTracker,0)
+};
+
+#endif
#pragma link C++ class AliEMCALFastRecParticle+;
#pragma link C++ class AliEMCALPID+;
#pragma link C++ class AliEMCALPIDv1+;
+#pragma link C++ class AliEMCALTracker+;
#pragma link C++ class AliEMCALLoader+;
#pragma link C++ class AliEMCALReconstructor+;
#pragma link C++ class AliEMCALRawStream+;
AliEMCALFastRecParticle.cxx \
AliEMCALPID.cxx \
AliEMCALPIDv1.cxx \
+AliEMCALTracker.cxx \
AliEMCALLoader.cxx \
AliEMCALReconstructor.cxx \
AliEMCALRawStream.cxx
#include "AliPHOSTrackSegmentMakerv1.h"
#include "AliPHOSPIDv1.h"
#include "AliPHOSGetter.h"
+#include "AliPHOSTracker.h"
#include "AliRawReaderFile.h"
//____________________________________________________________________________
void AliPHOSReconstructor::FillESD(AliRunLoader* runLoader, AliESD* esd) const
{
- // Called by AliReconstruct after Reconstruct() and global tracking and vertxing
- //Creates the tracksegments and Recparticles
-
- Int_t eventNumber = runLoader->GetEventNumber() ;
+ // This function creates AliESDtracks from AliPHOSRecParticles
+ // and
+ // writes them to the ESD
- TString headerFile(runLoader->GetFileName()) ;
- TString branchName(runLoader->GetEventFolder()->GetName()) ;
-
- AliPHOSTrackSegmentMakerv1 tsm(headerFile, branchName);
- tsm.SetESD(esd) ;
- AliPHOSPIDv1 pid(headerFile, branchName);
+ Int_t eventNumber = runLoader->GetEventNumber() ;
- // do current event; the loop over events is done by AliReconstruction::Run()
- tsm.SetEventRange(eventNumber, eventNumber) ;
- pid.SetEventRange(eventNumber, eventNumber) ;
- if ( Debug() ) {
- tsm.ExecuteTask("deb all") ;
- pid.ExecuteTask("deb all") ;
- }
- else {
- tsm.ExecuteTask("") ;
- pid.ExecuteTask("") ;
- }
-
- // Creates AliESDtrack from AliPHOSRecParticles
AliPHOSGetter::Instance()->Event(eventNumber, "P") ;
TClonesArray *recParticles = AliPHOSGetter::Instance()->RecParticles();
Int_t nOfRecParticles = recParticles->GetEntries();
delete et;
}
}
+
+AliTracker* AliPHOSReconstructor::CreateTracker(AliRunLoader* runLoader) const
+{
+// creates the PHOS tracker
+ if (!runLoader) return NULL;
+ return new AliPHOSTracker(runLoader);
+}
+
static void SetDebug() { fgDebug = kTRUE ; }
static void ResetDebug() { fgDebug = kFALSE ; }
static Bool_t Debug() { return fgDebug ; }
+ AliTracker *CreateTracker(AliRunLoader* runLoader) const;
virtual void FillESD(AliRunLoader* runLoader, AliESD* esd) const ;
virtual void Reconstruct(AliRunLoader* runLoader) const ;
virtual void Reconstruct(AliRunLoader* runLoader, AliRawReaderFile * rawreader) const ;
Int_t iClosestTrack = -1;
Double_t minDistance = 1e6;
Double_t pxyz[3], xyz[3];
+ Double_t rPHOS=460.;
AliESDtrack *track;
for (Int_t iTrack=0; iTrack<nTracks; iTrack++) {
track = fESD->GetTrack(iTrack);
if (track->IsPHOS())
continue ;
- track->GetOuterXYZPHOS(xyz); // track coord on the cylinder of PHOS radius
+ if (!track->GetXYZAt(rPHOS,xyz))
+ continue; //track coord on the cylinder of PHOS radius
if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
- continue;
- track->GetOuterPxPyPzPHOS(pxyz); // track momentum ibid.
+ continue;
+ if (!track->GetPxPyPzAt(rPHOS,pxyz))
+ continue; // track momentum ibid.
vecDist = PropagateToPlane(xyz,pxyz,"CPV",cpvClu->GetPHOSMod());
// Info("GetDistanceInPHOSPlane","Track %d propagation to CPV = (%f,%f,%f)",
// iTrack,vecDist.X(),vecDist.Y(),vecDist.Z());
if (iClosestTrack != -1) {
track = fESD->GetTrack(iClosestTrack);
- track->GetOuterPxPyPzPHOS(pxyz); // track momentum ibid.
+ if (track->GetPxPyPzAt(rPHOS,pxyz)) { // track momentum ibid.
TVector3 vecCpvGlobal; // Global position of the CPV recpoint
AliPHOSGetter * gime = AliPHOSGetter::Instance() ;
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
// iClosestTrack,vecDist.X(),vecDist.Y(),vecDist.Z());
vecDist -= vecEmc;
distance2Track = TMath::Sqrt(vecDist.X()*vecDist.X() + vecDist.Z()*vecDist.Z());
+ }
}
// } else {
// // If no ESD exists, than simply find EMC-CPV distance
--- /dev/null
+#include "AliPHOSTracker.h"
+#include "AliPHOSTrackSegmentMakerv1.h"
+#include "AliPHOSPIDv1.h"
+#include "AliRunLoader.h"
+#include "AliESD.h"
+
+//-------------------------------------------------------------------------
+// PHOS tracker.
+// Matches ESD tracks with the PHOS and makes the PID.
+// Currently, has only one function implemented : PropagateBack(AliESD*)
+//-------------------------------------------------------------------------
+
+ClassImp(AliPHOSTracker)
+
+Bool_t AliPHOSTracker::fgDebug = kFALSE ;
+
+Int_t AliPHOSTracker::PropagateBack(AliESD *esd) {
+ // Called by AliReconstruction
+ // Creates the tracksegments and Recparticles
+ // Makes the PID
+
+ Int_t eventNumber = fRunLoader->GetEventNumber() ;
+
+ TString headerFile(fRunLoader->GetFileName()) ;
+ TString branchName(fRunLoader->GetEventFolder()->GetName()) ;
+
+ AliPHOSTrackSegmentMakerv1 tsm(headerFile, branchName);
+ tsm.SetESD(esd) ;
+ AliPHOSPIDv1 pid(headerFile, branchName);
+
+ // do current event; the loop over events is done by AliReconstruction::Run()
+ tsm.SetEventRange(eventNumber, eventNumber) ;
+ pid.SetEventRange(eventNumber, eventNumber) ;
+ if ( Debug() ) {
+ tsm.ExecuteTask("deb all") ;
+ pid.ExecuteTask("deb all") ;
+ }
+ else {
+ tsm.ExecuteTask("") ;
+ pid.ExecuteTask("") ;
+ }
+
+ return 0;
+}
--- /dev/null
+#ifndef AliPHOSTracker_h
+#define AliPHOSTracker_h
+
+//-------------------------------------------------------------------------
+// PHOS tracker.
+// Matches ESD tracks with the PHOS and makes the PID.
+// Currently, has only one function implemented : PropagateBack(AliESD*).
+//-------------------------------------------------------------------------
+
+#include <AliTracker.h>
+#include <AliLog.h>
+
+class AliCluster;
+class AliESD;
+class TTree;
+class AliRunLoader;
+
+class AliPHOSTracker : public AliTracker
+{
+public:
+ AliPHOSTracker():AliTracker() {fRunLoader=0;}
+ AliPHOSTracker(AliRunLoader *loader):AliTracker() {fRunLoader=loader;}
+ virtual ~AliPHOSTracker() {AliDebug(1,"Start.");}
+
+ Int_t Clusters2Tracks(AliESD *) {AliDebug(1,"Start.");return 0;}
+ Int_t RefitInward(AliESD *) {AliDebug(1,"Start.");return 0;}
+ void UnloadClusters() {AliDebug(1,"Start.");}
+ AliCluster *GetCluster(Int_t ) const {AliDebug(1,"Start.");return 0;}
+ Int_t PropagateBack(AliESD *);
+ Int_t LoadClusters(TTree *) {AliDebug(1,"Start.");return 0;}
+
+ static void SetDebug() { fgDebug = kTRUE ; }
+ static void ResetDebug() { fgDebug = kFALSE ; }
+ static Bool_t Debug() { return fgDebug ; }
+
+private:
+ static Bool_t fgDebug ; //! Verbosity controller
+ AliRunLoader *fRunLoader; //! Pointer to the run loader
+ ClassDef(AliPHOSTracker,0)
+};
+
+#endif
#pragma link C++ class AliPHOSRawStream+;
#pragma link C++ class AliPHOSOnlineMonitor+;
#pragma link C++ class AliPHOSGetterLight+;
+#pragma link C++ class AliPHOSTracker+;
#endif
AliPHOSFastGlobalReconstruction.cxx AliPHOSGetter.cxx \
AliPHOSGammaJet.cxx \
AliPHOSGridFile.cxx AliPHOSRawStream.cxx AliPHOSRawReaderDate.cxx \
- AliPHOSGetterLight.cxx AliPHOSOnlineMonitor.cxx
+ AliPHOSGetterLight.cxx AliPHOSOnlineMonitor.cxx AliPHOSTracker.cxx
HDRS:= $(SRCS:.cxx=.h)
fIx(0),
fTalpha(0),
fTx(0),
-fOalpha(0),
-fOx(0),
fITSchi2(0),
fITSncls(0),
fITSsignal(0),
fEMCALpos[0]=fEMCALpos[1]=fEMCALpos[2]=0.;
Int_t i;
for (i=0; i<5; i++) {
- fRp[i]=fCp[i]=fIp[i]=fOp[i]=fXp[i]=fTp[i]=0.;
+ fRp[i]=fCp[i]=fIp[i]=fTp[i]=0.;
}
for (i=0; i<15; i++) {
- fRc[i]=fCc[i]=fIc[i]=fOc[i]=fXc[i]=fTc[i]=0.;
+ fRc[i]=fCc[i]=fIc[i]=fTc[i]=0.;
}
for (i=0; i<6; i++) { fITSindex[i]=0; }
for (i=0; i<180; i++){ fTPCindex[i]=0; }
for (Int_t i=0;i<5;i++) fTp[i] =track.fTp[i];
for (Int_t i=0;i<15;i++) fTc[i] =track.fTc[i];
//
- fOalpha =track.fOalpha;
- fOx =track.fOx;
- for (Int_t i=0;i<5;i++) fOp[i] =track.fOp[i];
- for (Int_t i=0;i<15;i++) fOc[i] =track.fOc[i];
- //
- fXalpha =track.fXalpha;
- fXx =track.fXx;
- for (Int_t i=0;i<5;i++) fXp[i] =track.fXp[i];
- for (Int_t i=0;i<15;i++) fXc[i] =track.fXc[i];
- //
fITSchi2 =track.fITSchi2;
for (Int_t i=0;i<12;i++) fITSchi2MIP[i] =track.fITSchi2MIP[i];
fITSncls =track.fITSncls;
//
break;
- case kTRDout:
- //requested by the PHOS/EMCAL ("temporary solution")
- if (GetExternalParametersAt(460.,fOp)) {
- fOalpha=t->GetAlpha();
- fOx=460.;
- t->GetExternalCovariance(fOc); //can be done better
- }
- if (GetExternalParametersAt(450.,fXp)) {
- fXalpha=t->GetAlpha();
- fXx=450.;
- t->GetExternalCovariance(fXc); //can be done better
- }
- case kTRDin: case kTRDrefit:
+ case kTRDout: case kTRDin: case kTRDrefit:
fTRDLabel = t->GetLabel();
fTRDncls=t->GetNumberOfClusters();
fTRDchi2=t->GetChi2();
// Cov(y,x) ... : cv[1] cv[2]
// Cov(z,x) ... : cv[3] cv[4] cv[5]
// Cov(px,x)... : cv[6] cv[7] cv[8] cv[9]
- // Cov(py,y)... : cv[10] cv[11] cv[12] cv[13] cv[14]
- // Cov(pz,z)... : cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
+ // Cov(py,x)... : cv[10] cv[11] cv[12] cv[13] cv[14]
+ // Cov(pz,x)... : cv[15] cv[16] cv[17] cv[18] cv[19] cv[20]
//
// Results for (nearly) straight tracks are meaningless !
//---------------------------------------------------------------------
for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
}
-void AliESDtrack::GetOuterPxPyPzPHOS(Double_t *p) const {
- //---------------------------------------------------------------------
- // This function returns the global track momentum components
- // af the radius of the PHOS
- //---------------------------------------------------------------------
- p[0]=p[1]=p[2]=0. ;
- if (fOx==0)
- return;
- Double_t phi=TMath::ASin(fOp[2]) + fOalpha;
- Double_t pt=1./TMath::Abs(fOp[4]);
- p[0]=pt*TMath::Cos(phi);
- p[1]=pt*TMath::Sin(phi);
- p[2]=pt*fOp[3];
-}
-void AliESDtrack::GetOuterPxPyPzEMCAL(Double_t *p) const {
+Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
//---------------------------------------------------------------------
// This function returns the global track momentum components
- // af the radius of the EMCAL
+ // at the position "x" using the helix track approximation
//---------------------------------------------------------------------
- if (fXx==0)
- return;
- Double_t phi=TMath::ASin(fXp[2]) + fXalpha;
- Double_t pt=1./TMath::Abs(fXp[4]);
- p[0]=pt*TMath::Cos(phi);
- p[1]=pt*TMath::Sin(phi);
- p[2]=pt*fXp[3];
+ Double_t dx=x-fRx;
+ Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+
+ if (TMath::Abs(f2) >= 0.9999) return kFALSE;
+
+ Double_t r2=TMath::Sqrt(1.- f2*f2);
+
+ Double_t pt=1./TMath::Abs(fRp[4]);
+ Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
+ p[0]=pt*(r2*cs - f2*sn); p[1]=pt*(f2*cs + r2*sn); p[2]=pt*fRp[3];
+
+ return kTRUE;
}
-void AliESDtrack::GetOuterXYZPHOS(Double_t *xyz) const {
- //---------------------------------------------------------------------
- // This function returns the global track position
- // af the radius of the PHOS
- //---------------------------------------------------------------------
- xyz[0]=xyz[1]=xyz[2]=0.;
- if (fOx==0)
- return;
- Double_t phi=TMath::ATan2(fOp[0],fOx) + fOalpha;
- Double_t r=TMath::Sqrt(fOx*fOx + fOp[0]*fOp[0]);
- xyz[0]=r*TMath::Cos(phi); xyz[1]=r*TMath::Sin(phi); xyz[2]=fOp[1];
-}
-void AliESDtrack::GetOuterXYZEMCAL(Double_t *xyz) const {
+Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *xyz) const {
//---------------------------------------------------------------------
// This function returns the global track position
- // af the radius of the EMCAL
+ // af the radius "x" using the helix track approximation
//---------------------------------------------------------------------
- if (fXx==0)
- return;
- Double_t phi=TMath::ATan2(fXp[0],fOx) + fXalpha;
- Double_t r=TMath::Sqrt(fXx*fXx + fXp[0]*fXp[0]);
- xyz[0]=r*TMath::Cos(phi);
- xyz[1]=r*TMath::Sin(phi);
- xyz[2]=fXp[1];
-}
+ Double_t dx=x-fRx;
+ Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+
+ if (TMath::Abs(f2) >= 0.9999) return kFALSE;
+
+ Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
+ Double_t y = fRp[0] + dx*(f1+f2)/(r1+r2);
+ Double_t z = fRp[1] + dx*(f1+f2)/(f1*r2 + f2*r1)*fRp[3];
+
+ Double_t cs=TMath::Cos(fRalpha), sn=TMath::Sin(fRalpha);
+ xyz[0]=x*cs - y*sn; xyz[1]=x*sn + y*cs; xyz[2]=z;
+
+ return kTRUE;
+}
//_______________________________________________________________________
void AliESDtrack::GetIntegratedTimes(Double_t *times) const {
//
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
+/*****************************************************************************
+ * Use GetExternalParameters() and GetExternalCovariance() to access the *
+ * track information regardless of its internal representation. *
+ * This formation is now fixed in the following way: *
+ * external param0: local Y-coordinate of a track (cm) *
+ * external param1: local Z-coordinate of a track (cm) *
+ * external param2: local sine of the track momentum azimuthal angle *
+ * external param3: tangent of the track momentum dip angle *
+ * external param4: 1/pt (1/(GeV/c)) *
+ *****************************************************************************/
#include <TBits.h>
#include <TObject.h>
Int_t GetLabel() const {return fLabel;}
Double_t GetAlpha() const {return fRalpha;}
void GetExternalParameters(Double_t &x, Double_t p[5]) const;
- Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
void GetExternalCovariance(Double_t cov[15]) const;
+
+ Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
+ Bool_t GetPxPyPzAt(Double_t x, Double_t p[3]) const;
+ Bool_t GetXYZAt(Double_t x, Double_t r[3]) const;
+
Double_t GetIntegratedLength() const {return fTrackLength;}
void GetIntegratedTimes(Double_t *times) const;
Double_t GetMass() const;
void GetInnerExternalCovariance(Double_t cov[15]) const;//skowron
Double_t GetInnerAlpha() const {return fIalpha;}
-
- void GetOuterPxPyPzPHOS(Double_t *p) const;
- void GetOuterPxPyPzEMCAL(Double_t *p) const;
- void GetOuterXYZPHOS(Double_t *r) const;
- void GetOuterXYZEMCAL(Double_t *r) const;
-
void SetITSpid(const Double_t *p);
void SetITSChi2MIP(const Float_t *chi2mip);
void SetITStrack(AliKalmanTrack * track){fITStrack=track;}
Double_t fIx; // x-coordinate of the track reference plane
Double_t fIp[5]; // external track parameters
Double_t fIc[15]; // external cov. matrix of the track parameters
+
//Track parameters at the inner wall of the TRD
Double_t fTalpha; // Track rotation angle
Double_t fTx; // x-coordinate of the track reference plane
Double_t fTp[5]; // external track parameters
Double_t fTc[15]; // external cov. matrix of the track parameters
-//Track parameters at the radius of the PHOS
- Double_t fOalpha; //! Track rotation angle
- Double_t fOx; //! x-coordinate of the track reference plane
- Double_t fOp[5]; //! external track parameters
- Double_t fOc[15]; //! external cov. matrix of the track parameters
-
-//Track parameters at the radius of the EMCAL
- Double_t fXalpha; //! Track rotation angle
- Double_t fXx; //! x-coordinate of the track reference plane
- Double_t fXp[5]; //! external track parameters
- Double_t fXc[15]; //! external cov. matrix of the track parameters
-
// ITS related track information
Float_t fITSchi2; // chi2 in the ITS
Float_t fITSchi2MIP[12]; // chi2s in the ITS
Float_t fTPCPoints[4]; // TPC points -first, max. dens, last and max density
Int_t fKinkIndexes[3]; // array of indexes of posible kink candidates
Int_t fV0Indexes[3]; // array of indexes of posible kink candidates
+
// TRD related track information
Float_t fTRDchi2; // chi2 in the TRD
Int_t fTRDncls; // number of clusters assigned in the TRD
Float_t fTRDr[kSPECIES]; // "detector response probabilities" (for the PID)
Int_t fTRDLabel; // label according TRD
AliKalmanTrack * fTRDtrack; //! OWNER: pointer to the TRD track -- currently for debug purpose
+
// TOF related track information
Float_t fTOFchi2; // chi2 in the TOF
UInt_t fTOFindex; // index of the assigned TOF cluster
Float_t fTOFr[kSPECIES]; // "detector response probabilities" (for the PID)
Int_t fTOFLabel[3]; // TOF label
Float_t fTOFInfo[10]; //! TOF informations
+
// PHOS related track information
Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system
Float_t fPHOSsignal; // energy measured by PHOS
fTRDTracker(NULL),
fTOFLoader(NULL),
fTOFTracker(NULL),
+ fPHOSLoader(NULL),
+ fPHOSTracker(NULL),
+ fEMCALLoader(NULL),
+ fEMCALTracker(NULL),
fRICHLoader(NULL),
fRICHTracker(NULL),
fTRDTracker(NULL),
fTOFLoader(NULL),
fTOFTracker(NULL),
+ fPHOSLoader(NULL),
+ fPHOSTracker(NULL),
+ fEMCALLoader(NULL),
+ fEMCALTracker(NULL),
fRICHLoader(NULL),
fRICHTracker(NULL),
}
if (fCheckPointLevel > 1) WriteESD(esd, "ITS.tracking");
- if (fTRDTracker || fTOFTracker) {
+ if (fTRDTracker||fTOFTracker||fPHOSTracker||fEMCALTracker||fRICHTracker) {
// ITS back propagation
AliDebug(1, "ITS back propagation");
if (fITSTracker->PropagateBack(esd) != 0) {
fTOFTracker->UnloadClusters();
fTOFLoader->UnloadDigits();
+ if (!fPHOSTracker) {
+ AliWarning("no PHOS tracker");
+ } else {
+ // PHOS back propagation
+ AliDebug(1, "PHOS back propagation");
+ fPHOSLoader->LoadRecPoints("read");
+ TTree* phosTree = fPHOSLoader->TreeR();
+ if (!phosTree) {
+ AliError("Can't get the PHOS cluster tree");
+ return kFALSE;
+ }
+ fPHOSTracker->LoadClusters(phosTree);
+ if (fPHOSTracker->PropagateBack(esd) != 0) {
+ AliError("PHOS backward propagation failed");
+ return kFALSE;
+ }
+ if (fCheckPointLevel > 1) WriteESD(esd, "PHOS.back");
+ fPHOSTracker->UnloadClusters();
+ fPHOSLoader->UnloadRecPoints();
+ }
+
+ if (!fEMCALTracker) {
+ AliWarning("no EMCAL tracker");
+ } else {
+ // EMCAL back propagation
+ AliDebug(1, "EMCAL back propagation");
+ fEMCALLoader->LoadRecPoints("read");
+ TTree* emcalTree = fEMCALLoader->TreeR();
+ if (!emcalTree) {
+ AliError("Can't get the EMCAL cluster tree");
+ return kFALSE;
+ }
+ fEMCALTracker->LoadClusters(emcalTree);
+ if (fEMCALTracker->PropagateBack(esd) != 0) {
+ AliError("EMCAL backward propagation failed");
+ return kFALSE;
+ }
+ if (fCheckPointLevel > 1) WriteESD(esd, "EMCAL.back");
+ fEMCALTracker->UnloadClusters();
+ fEMCALLoader->UnloadRecPoints();
+ }
+
if (!fRICHTracker) {
AliWarning("no RICH tracker");
} else {
}
if (fCheckPointLevel > 1) WriteESD(esd, "ITS.refit");
- } // if TRD tracker
+ } // if TRD tracker or TOF tracker or PHOS tracker ...
fITSTracker->UnloadClusters();
fITSLoader->UnloadRecPoints();
}
}
+ fPHOSTracker = NULL;
+ fPHOSLoader = fRunLoader->GetLoader("PHOSLoader");
+ if (!fPHOSLoader) {
+ AliWarning("no PHOS loader found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ AliReconstructor* phosReconstructor = GetReconstructor("PHOS");
+ if (phosReconstructor) {
+ fPHOSTracker = phosReconstructor->CreateTracker(fRunLoader);
+ }
+ if (!fPHOSTracker) {
+ AliWarning("couldn't create a tracker for PHOS");
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
+ fEMCALTracker = NULL;
+ fEMCALLoader = fRunLoader->GetLoader("EMCALLoader");
+ if (!fEMCALLoader) {
+ AliWarning("no EMCAL loader found");
+ if (fStopOnError) return kFALSE;
+ } else {
+ AliReconstructor* emcalReconstructor = GetReconstructor("EMCAL");
+ if (emcalReconstructor) {
+ fEMCALTracker = emcalReconstructor->CreateTracker(fRunLoader);
+ }
+ if (!fEMCALTracker) {
+ AliWarning("couldn't create a tracker for EMCAL");
+ if (fStopOnError) return kFALSE;
+ }
+ }
+
fRICHTracker = NULL;
fRICHLoader = fRunLoader->GetLoader("RICHLoader");
if (!fRICHLoader) {
fTRDTracker = NULL;
delete fTOFTracker;
fTOFTracker = NULL;
+ delete fPHOSTracker;
+ fPHOSTracker = NULL;
+ delete fEMCALTracker;
+ fEMCALTracker = NULL;
delete fRICHTracker;
fRICHTracker = NULL;
AliTracker* fTRDTracker; //! tracker for TRD
AliLoader* fTOFLoader; //! loader for TOF
AliTracker* fTOFTracker; //! tracker for TOF
+ AliLoader* fPHOSLoader; //! loader for PHOS
+ AliTracker* fPHOSTracker; //! tracker for PHOS
+ AliLoader* fEMCALLoader; //! loader for EMCAL
+ AliTracker* fEMCALTracker; //! tracker for EMCAL
AliLoader* fRICHLoader; //! loader for RICH
AliTracker* fRICHTracker; //! tracker for RICH
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff