#include "AliTOFtrack.h"
extern TGeoManager *gGeoManager;
-extern TROOT *gROOT;
+//extern TROOT *gROOT;
ClassImp(AliTOFtracker)
fnbadmatch(0),
fnunmatch(0),
fnmatch(0),
+ fESDEv(0),
fTracks(new TClonesArray("AliTOFtrack")),
fSeeds(new TObjArray(100)),
fTOFtrackPoints(new TObjArray(10)),
fTime(-1.),
fExpTimePi(-1.),
fExpTimeKa(-1.),
- fExpTimePr(-1.)
+ fExpTimePr(-1.),
+ fNTOFmatched(0)
{
//AliTOFtracker main Ctor
// Getting the geometry
fGeom = new AliTOFGeometry();
-
+ /* RS?
+ for(Int_t i=0; i< 20000;i++){
+ fClusterESD[i] = NULL;
+ fHit[i] = NULL;
+ }
+ */
InitCheckHists();
}
for (Int_t ii=0; ii<kMaxCluster; ii++)
if (fClusters[ii]) fClusters[ii]->Delete();
+ /* RS?
+ for(Int_t i=0; i< 20000;i++){
+ if(fClusterESD[i]){
+ delete fClusterESD[i];
+ fClusterESD[i] = NULL;
+ }
+ if(fHit[i]){
+ delete fHit[i];
+ fHit[i] = NULL;
+ }
+ }
+ */
+
}
//_____________________________________________________________________________
void AliTOFtracker::GetPidSettings(AliESDpid *esdPID) {
//
// Gets seeds from ESD event and Match with TOF Clusters
//
+ fESDEv = event;
+ //
+ if (fN==0) {
+ AliInfo("No TOF recPoints to be matched with reconstructed tracks");
+ return 0;
+ }
// initialize RecoParam for current event
AliDebug(1,"Initializing params for TOF");
//if(fkRecoParam->GetApplyPbPbCuts())fkRecoParam=fkRecoParam->GetPbPbparam();
//fkRecoParam->PrintParameters();
+ /* RS?
+ // create clusters from hit
+ for(Int_t i=0;i < fNTOFmatched;i++){
+ fClusterESD[i] = new AliESDTOFCluster(fHit[i],event);
+ fClusterESD[i]->SetStatus(fClusters[i]->GetStatus());
+ }
+ */
//Initialise some counters
fNseeds=0;
//Load ESD tracks into a local Array of ESD Seeds
- for (Int_t i=0; i<fNseeds; i++)
+ for (Int_t i=0; i<fNseeds; i++){
fSeeds->AddLast(event->GetTrack(i));
-
+ // event->GetTrack(i)->SetESDEvent(event); // RS: Why this is needed? The event is already set
+ }
//Prepare ESD tracks candidates for TOF Matching
CollectESD();
+ if (fNseeds==0 || fNseedsTOF==0) {
+ AliInfo("No seeds to try TOF match");
+ fSeeds->Clear();
+ fTracks->Clear();
+ return 0 ;
+ }
+
//First Step with Strict Matching Criterion
- MatchTracks(kFALSE);
+ MatchTracks(0);
//Second Step with Looser Matching Criterion
- MatchTracks(kTRUE);
+ MatchTracks(1);
+
+ //Third Step without kTOFout flag (just to update clusters)
+ MatchTracks(2);
+
+ //RS? event->SetTOFcluster(fNTOFmatched,fClusterESD);
+
+ if (fN==0) {
+ AliInfo("No TOF recPoints to be matched with reconstructed tracks");
+ fSeeds->Clear();
+ fTracks->Clear();
+ return 0;
+ }
AliInfo(Form("Number of matched tracks = %d (good = %d, bad = %d)",fnmatch,fngoodmatch,fnbadmatch));
//Update the matched ESD tracks
for (Int_t i=0; i<ntrk; i++) {
- AliESDtrack *t=event->GetTrack(i);
+ // RS: This is a bogus code since t and seed are the same object
+ // AliESDtrack *t=event->GetTrack(i);
AliESDtrack *seed =(AliESDtrack*)fSeeds->At(i);
-
if ( (seed->GetStatus()&AliESDtrack::kTOFin)!=0 ) {
- t->SetStatus(AliESDtrack::kTOFin);
+ //t->SetStatus(AliESDtrack::kTOFin);
//if(seed->GetTOFsignal()>0){
if ( (seed->GetStatus()&AliESDtrack::kTOFout)!=0 ) {
- t->SetStatus(AliESDtrack::kTOFout);
- t->SetTOFsignal(seed->GetTOFsignal());
- t->SetTOFcluster(seed->GetTOFcluster());
- t->SetTOFsignalToT(seed->GetTOFsignalToT());
- t->SetTOFsignalRaw(seed->GetTOFsignalRaw());
- t->SetTOFsignalDz(seed->GetTOFsignalDz());
- t->SetTOFsignalDx(seed->GetTOFsignalDx());
- t->SetTOFDeltaBC(seed->GetTOFDeltaBC());
- t->SetTOFL0L1(seed->GetTOFL0L1());
- t->SetTOFCalChannel(seed->GetTOFCalChannel());
+ //t->SetStatus(AliESDtrack::kTOFout);
+ //t->SetTOFsignal(seed->GetTOFsignal());
+ //t->SetTOFcluster(seed->GetTOFcluster());
+ //t->SetTOFsignalToT(seed->GetTOFsignalToT());
+ //t->SetTOFsignalRaw(seed->GetTOFsignalRaw());
+ //t->SetTOFsignalDz(seed->GetTOFsignalDz());
+ //t->SetTOFsignalDx(seed->GetTOFsignalDx());
+ //t->SetTOFDeltaBC(seed->GetTOFDeltaBC());
+ //t->SetTOFL0L1(seed->GetTOFL0L1());
+ //t->SetTOFCalChannel(seed->GetTOFCalChannel());
Int_t tlab[3]; seed->GetTOFLabel(tlab);
- t->SetTOFLabel(tlab);
+ //t->SetTOFLabel(tlab);
- Double_t alphaA = (Double_t)t->GetAlpha();
- Double_t xA = (Double_t)t->GetX();
- Double_t yA = (Double_t)t->GetY();
- Double_t zA = (Double_t)t->GetZ();
- Double_t p1A = (Double_t)t->GetSnp();
- Double_t p2A = (Double_t)t->GetTgl();
- Double_t p3A = (Double_t)t->GetSigned1Pt();
- const Double_t *covA = (Double_t*)t->GetCovariance();
+ Double_t alphaA = (Double_t)seed->GetAlpha();
+ Double_t xA = (Double_t)seed->GetX();
+ Double_t yA = (Double_t)seed->GetY();
+ Double_t zA = (Double_t)seed->GetZ();
+ Double_t p1A = (Double_t)seed->GetSnp();
+ Double_t p2A = (Double_t)seed->GetTgl();
+ Double_t p3A = (Double_t)seed->GetSigned1Pt();
+ const Double_t *covA = (Double_t*)seed->GetCovariance();
// Make attention, please:
// AliESDtrack::fTOFInfo array does not be stored in the AliESDs.root file
// it is there only for a check during the reconstruction step.
Float_t info[10]; seed->GetTOFInfo(info);
- t->SetTOFInfo(info);
+ //t->SetTOFInfo(info);
AliDebug(3,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2]));
// Check done:
AliTOFtrack *track = new AliTOFtrack(*seed);
t->UpdateTrackParams(track,AliESDtrack::kTOFout); // to be checked - AdC
delete track;
- Double_t time[10]; t->GetIntegratedTimes(time);
+ Double_t time[AliPID::kSPECIESC]; t->GetIntegratedTimes(time);
*/
- Double_t time[10]; seed->GetIntegratedTimes(time);
- t->SetIntegratedTimes(time);
-
- Double_t length = seed->GetIntegratedLength();
- t->SetIntegratedLength(length);
-
- Double_t alphaB = (Double_t)t->GetAlpha();
- Double_t xB = (Double_t)t->GetX();
- Double_t yB = (Double_t)t->GetY();
- Double_t zB = (Double_t)t->GetZ();
- Double_t p1B = (Double_t)t->GetSnp();
- Double_t p2B = (Double_t)t->GetTgl();
- Double_t p3B = (Double_t)t->GetSigned1Pt();
- const Double_t *covB = (Double_t*)t->GetCovariance();
- AliDebug(2,"Track params -now(before)-:");
- AliDebug(2,Form(" X: %f(%f), Y: %f(%f), Z: %f(%f) --- alpha: %f(%f)",
+ Double_t time[AliPID::kSPECIESC]; seed->GetIntegratedTimes(time,AliPID::kSPECIESC);
+ //t->SetIntegratedTimes(time);
+
+ //Double_t length = seed->GetIntegratedLength();
+ //t->SetIntegratedLength(length);
+
+ Double_t alphaB = (Double_t)seed->GetAlpha();
+ Double_t xB = (Double_t)seed->GetX();
+ Double_t yB = (Double_t)seed->GetY();
+ Double_t zB = (Double_t)seed->GetZ();
+ Double_t p1B = (Double_t)seed->GetSnp();
+ Double_t p2B = (Double_t)seed->GetTgl();
+ Double_t p3B = (Double_t)seed->GetSigned1Pt();
+ const Double_t *covB = (Double_t*)seed->GetCovariance();
+ AliDebug(3,"Track params -now(before)-:");
+ AliDebug(3,Form(" X: %f(%f), Y: %f(%f), Z: %f(%f) --- alpha: %f(%f)",
xB,xA,
yB,yA,
zB,zA,
alphaB,alphaA));
- AliDebug(2,Form(" p1: %f(%f), p2: %f(%f), p3: %f(%f)",
+ AliDebug(3,Form(" p1: %f(%f), p2: %f(%f), p3: %f(%f)",
p1B,p1A,
p2B,p2A,
p3B,p3A));
- AliDebug(2,Form(" cov1: %f(%f), cov2: %f(%f), cov3: %f(%f)"
+ AliDebug(3,Form(" cov1: %f(%f), cov2: %f(%f), cov3: %f(%f)"
" cov4: %f(%f), cov5: %f(%f), cov6: %f(%f)"
" cov7: %f(%f), cov8: %f(%f), cov9: %f(%f)"
" cov10: %f(%f), cov11: %f(%f), cov12: %f(%f)"
covB[13],covA[13],
covB[14],covA[14]
));
- AliDebug(3,Form(" TOF params: %6d %f %f %f %f %f %6d %3d %f %f %f %f %f %f",
+ AliDebug(2,Form(" TOF params: %6d %f %f %f %f %f %6d %3d %f",
i,
- t->GetTOFsignalRaw(),
- t->GetTOFsignal(),
- t->GetTOFsignalToT(),
- t->GetTOFsignalDz(),
- t->GetTOFsignalDx(),
- t->GetTOFCalChannel(),
- t->GetTOFcluster(),
- t->GetIntegratedLength(),
- time[0], time[1], time[2], time[3], time[4]
- )
- );
+ seed->GetTOFsignalRaw(),
+ seed->GetTOFsignal(),
+ seed->GetTOFsignalToT(),
+ seed->GetTOFsignalDz(),
+ seed->GetTOFsignalDx(),
+ seed->GetTOFCalChannel(),
+ seed->GetTOFcluster(),
+ seed->GetIntegratedLength()));
+ AliDebug(2,Form(" %f %f %f %f %f %f %f %f %f",
+ time[0], time[1], time[2], time[3], time[4], time[5], time[6], time[7], time[8]));
}
}
}
+ /* RS?
+ if(fNTOFmatched){
+ Int_t *matchmap = new Int_t[fNTOFmatched];
+ event->SetTOFcluster(fNTOFmatched,fClusterESD,matchmap);
+ for (Int_t i=0; i<ntrk; i++) { // remapping after TOF matching selection
+ AliESDtrack *t=event->GetTrack(i);
+ t->ReMapTOFcluster(fNTOFmatched,matchmap);
+ }
+
+ delete[] matchmap;
+ }
+ */
//Make TOF PID
// Now done in AliESDpid
}
//_________________________________________________________________________
-void AliTOFtracker::MatchTracks( Bool_t mLastStep){
+void AliTOFtracker::MatchTracks( Int_t mLastStep){
// Parameters used/regulating the reconstruction
AliInfo(Form("Matching window=%f, since low multiplicity event (fNseedsTOF=%d)",
dCut, fNseedsTOF));
}
+ if(mLastStep == 2)
+ dCut=10.;
+
+
Double_t maxChi2=fkRecoParam->GetMaxChi2TRD();
Bool_t timeWalkCorr = fkRecoParam->GetTimeWalkCorr();
if(!mLastStep){
- AliDebug(1,"++++++++++++++TOF Reconstruction Parameters:++++++++++++ \n");
+ AliDebug(1,"++++++++++++++TOF Reconstruction Parameters:++++++++++++");
AliDebug(1,Form("TOF sens radius: %f",sensRadius));
AliDebug(1,Form("TOF step size: %f",stepSize));
AliDebug(1,Form("TOF Window scale factor: %f",scaleFact));
Int_t nSteps=(Int_t)(detDepth/stepSize);
AliDebug(1,Form(" Number of steps to be done %d",nSteps));
+ AliDebug(1,"++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
+
//PH Arrays (moved outside of the loop)
Float_t * trackPos[4];
for (Int_t ii=0; ii<4; ii++) trackPos[ii] = new Float_t[nSteps];
AliTOFtrack *track =(AliTOFtrack*)fTracks->UncheckedAt(iseed);
AliESDtrack *t =(AliESDtrack*)fSeeds->At(track->GetSeedIndex());
//if ( t->GetTOFsignal()>0. ) continue;
- if ( (t->GetStatus()&AliESDtrack::kTOFout)!=0 ) continue;
+ if ( ((t->GetStatus()&AliESDtrack::kTOFout)!=0 ) && mLastStep < 2) continue;
AliTOFtrack *trackTOFin = new AliTOFtrack(*track);
// Determine a window around the track
AliTOFcluster *c=fClusters[k];
if (c->GetZ() > z+dz) break;
- if (c->IsUsed()) continue;
+ if (c->IsUsed() && mLastStep < 2) continue;
if (!c->GetStatus()) {
AliDebug(1,"Cluster in channel declared bad!");
continue; // skip bad channels as declared in OCDB
nc++;
}
- AliDebug(1,Form(" Number of matchable TOF clusters for the track number %d: %d",iseed,nc));
-
if (nc == 0 ) {
+ AliDebug(1,Form("No available clusters for the track number %d",iseed));
fnunmatch++;
delete trackTOFin;
continue;
}
+ AliDebug(1,Form(" Number of available TOF clusters for the track number %d: %d",iseed,nc));
+
//start fine propagation
Int_t nStepsDone = 0;
}
nStepsDone++;
- AliDebug(2,Form(" current step %d (%d) - nStepsDone=%d",istep,nSteps,nStepsDone));
+ AliDebug(3,Form(" current step %d (%d) - nStepsDone=%d",istep,nSteps,nStepsDone));
// store the running point (Globalrf) - fine propagation
Float_t yLoc = dist3d[1];
Float_t rLoc = TMath::Sqrt(dist3d[0]*dist3d[0]+dist3d[2]*dist3d[2]);
accept = (TMath::Abs(yLoc)<padDepth*0.5 && rLoc<dCut);
- AliDebug(2," I am in the case mLastStep==kTRUE ");
+ AliDebug(3," I am in the case mLastStep==kTRUE ");
}
else {
accept = isInside;
dist3d[2],dist3d[0],dist3d[1],
AliTOFGeometry::RinTOF()+istep*stepSize,trackPos[3][istep]));
- AliDebug(2,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",dist3d[0],dist3d[1],dist3d[2]));
+ AliDebug(3,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",dist3d[0],dist3d[1],dist3d[2]));
nfound++;
if(accept &&!mLastStep)break;
}//end if accept
/*****************/
#endif
- AliDebug(1,Form(" Number of steps done for the track number %d: %d",iseed,nStepsDone));
-
if ( nStepsDone == 0 ) {
+ AliDebug(1,Form(" No track points for the track number %d",iseed));
fnunmatch++;
delete trackTOFin;
continue;
}
+ AliDebug(2,Form(" Number of steps done for the track number %d: %d",iseed,nStepsDone));
+
/*****************/
/**** NEW CODE ***/
/*****************/
+ Int_t *isClusterMatchable = NULL;
+ if(nc){
+ isClusterMatchable = new Int_t[nc];
+ for (Int_t i=0; i<nc; i++) isClusterMatchable[i] = kFALSE;
+ }
+
Int_t nfound = 0;
Bool_t accept = kFALSE;
Bool_t isInside = kFALSE;
* this will allow to only go on and add track points for
* that cluster where the track got inside first */
if (gotInsideCluster && trackInsideCluster != i) {
- AliDebug(2,Form(" A - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
+ AliDebug(3,Form(" A - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
continue;
}
- AliDebug(2,Form(" B - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
+ AliDebug(3,Form(" B - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
/* check whether track is inside this cluster */
for (Int_t hh=0; hh<3; hh++) dist3d[hh]=0.;
Float_t yLoc = dist3d[1];
Float_t rLoc = TMath::Sqrt(dist3d[0]*dist3d[0]+dist3d[2]*dist3d[2]);
accept = (TMath::Abs(yLoc)<padDepth*0.5 && rLoc<dCut);
- AliDebug(2," I am in the case mLastStep==kTRUE ");
+ AliDebug(3," I am in the case mLastStep==kTRUE ");
}
//***** NEW *****
AliDebug(2,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",dist3d[0],dist3d[1],dist3d[2]));
nfound++;
- AliDebug(2,Form(" C - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
-
+ AliDebug(3,Form(" C - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
+
+ // store the match in the ESD
+ if (mLastStep==2 && !isClusterMatchable[i]) { // add TOF clusters to the track
+ //
+ isClusterMatchable[i] = kTRUE;
+ //Tracking info
+ Double_t mom=t->GetP();
+ AliDebug(3,Form(" Momentum for track %d -> %f", iseed,mom));
+ Double_t time[AliPID::kSPECIESC];
+ // read from old structure (the one used by TPC in reco)
+ for(Int_t isp=0;isp<AliPID::kSPECIESC;isp++){
+ time[isp] = t->GetIntegratedTimesOld(isp); // in ps
+ Double_t mass=AliPID::ParticleMass(isp);
+ Double_t momz = mom*AliPID::ParticleCharge(isp);
+ time[isp]+=(trackPos[3][istep]-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(momz*momz+mass*mass)/momz;
+ //time[isp]+=(trackPos[3][istep]-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(mom*mom+mass*mass)/mom;
+ }
+ //
+ AliESDTOFCluster* esdTOFCl = GetESDTOFCluster(clind[i]);
+ if(!esdTOFCl->Update(t->GetID(),dist3d[0],dist3d[1],dist3d[2],trackPos[3][istep],time))//x,y,z -> tracking RF
+ t->AddTOFcluster(esdTOFCl->GetESDID());
+ }
+
// ***** NEW *****
/* do not break loop in any case
* if the track got inside a cluster all other clusters
// if(accept &&!mLastStep)break;
} //end for on the steps
-
-
- AliDebug(1,Form(" Number of track points for the track number %d: %d",iseed,nfound));
+ if(nc) delete[] isClusterMatchable;
if (nfound == 0 ) {
+ AliDebug(1,Form("No track points for the track number %d",iseed));
fnunmatch++;
delete trackTOFin;
continue;
}
+ AliDebug(1,Form(" Number of track points for the track number %d: %d",iseed,nfound));
+
// now choose the cluster to be matched with the track.
Int_t idclus=-1;
idclus = matchableTOFcluster->Index();
recL = matchableTOFcluster->Length();// + corrLen*0.5;
- AliDebug(1,Form(" %d(%d) --- %f (%f, %f, %f), step=%f -- idclus=%d --- seed=%d, trackId=%d, trackLab=%d", iclus,nfound,
+ AliDebug(2,Form(" %d(%d) --- %f (%f, %f, %f), step=%f -- idclus=%d --- seed=%d, trackId=%d, trackLab=%d", iclus,nfound,
mindist,mindistX,mindistY,mindistZ,stepSize,idclus,iseed,track->GetSeedIndex(),track->GetLabel()));
}
} // loop on found TOF track points
if (TMath::Abs(mindistX)>stepSize && idclus!=-1) {
- AliInfo(Form("--------Not matched --- but idclus=%d, trackId=%d, trackLab=%d",
+ AliInfo(Form(" %d - not matched --- but idclus=%d, trackId=%d, trackLab=%d",iseed,
idclus,track->GetSeedIndex(),track->GetLabel()));
idclus=-1;
}
continue;
}
- AliDebug(1,"--------Matched");
+ AliDebug(1,Form(" %d - matched",iseed));
fnmatch++;
AliTOFcluster *c=fClusters[idclus];
- AliDebug(2, Form("%7d %7d %10d %10d %10d %10d %7d",
+ AliDebug(3, Form("%7d %7d %10d %10d %10d %10d %7d",
iseed,
fnmatch-1,
TMath::Abs(trackTOFin->GetLabel()),
// Store quantities to be used in the TOF Calibration
Float_t tToT=AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3; // in ns
- t->SetTOFsignalToT(tToT);
+// t->SetTOFsignalToT(tToT);
Float_t rawTime=AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW()+kTimeOffset; // RAW time,in ps
- t->SetTOFsignalRaw(rawTime);
- t->SetTOFsignalDz(mindistZ);
- t->SetTOFsignalDx(mindistY);
- t->SetTOFDeltaBC(c->GetDeltaBC());
- t->SetTOFL0L1(c->GetL0L1Latency());
+// t->SetTOFsignalRaw(rawTime);
+// t->SetTOFsignalDz(mindistZ);
+// t->SetTOFsignalDx(mindistY);
+// t->SetTOFDeltaBC(c->GetDeltaBC());
+// t->SetTOFL0L1(c->GetL0L1Latency());
Float_t info[10] = {mindist,mindistY,mindistZ,
0.,0.,0.,0.,0.,0.,0.};
t->SetTOFInfo(info);
- AliDebug(2,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2]));
+ AliDebug(3,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2]));
Int_t ind[5];
ind[3]=c->GetDetInd(3);
ind[4]=c->GetDetInd(4);
Int_t calindex = AliTOFGeometry::GetIndex(ind);
- t->SetTOFCalChannel(calindex);
+// t->SetTOFCalChannel(calindex);
// keep track of the track labels in the matched cluster
Int_t tlab[3];
tlab[0]=c->GetLabel(0);
tlab[1]=c->GetLabel(1);
tlab[2]=c->GetLabel(2);
- AliDebug(2,Form(" tdc time of the matched track %6d = ",c->GetTDC()));
+ AliDebug(3,Form(" tdc time of the matched track %6d = ",c->GetTDC()));
Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+kTimeOffset; // in ps
- AliDebug(2,Form(" tof time of the matched track: %f = ",tof));
+ AliDebug(3,Form(" tof time of the matched track: %f = ",tof));
Double_t tofcorr=tof;
if(timeWalkCorr)tofcorr=CorrectTimeWalk(mindistZ,tof);
- AliDebug(2,Form(" tof time of the matched track, after TW corr: %f = ",tofcorr));
+ AliDebug(3,Form(" tof time of the matched track, after TW corr: %f = ",tofcorr));
//Set TOF time signal and pointer to the matched cluster
- t->SetTOFsignal(tofcorr);
+// t->SetTOFsignal(tofcorr);
t->SetTOFcluster(idclus); // pointing to the recPoints tree
- AliDebug(2,Form(" Setting TOF raw time: %f, z distance: %f corrected time: %f ",rawTime,mindistZ,tofcorr));
+ AliDebug(3,Form(" Setting TOF raw time: %f, z distance: %f corrected time: %f ",rawTime,mindistZ,tofcorr));
//Tracking info
- Double_t time[AliPID::kSPECIES]; t->GetIntegratedTimes(time); // in ps
+ Double_t time[AliPID::kSPECIESC];
+ // read from old structure (the one used by TPC in reco)
+ for(Int_t isp=0;isp<AliPID::kSPECIESC;isp++){
+ time[isp] = t->GetIntegratedTimesOld(isp); // in ps
+ }
Double_t mom=t->GetP();
- AliDebug(2,Form(" Momentum for track %d -> %f", iseed,mom));
- for (Int_t j=0;j<AliPID::kSPECIES;j++) {
+ AliDebug(3,Form(" Momentum for track %d -> %f", iseed,mom));
+ for (Int_t j=0;j<AliPID::kSPECIESC;j++) {
Double_t mass=AliPID::ParticleMass(j);
- time[j]+=(recL-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(mom*mom+mass*mass)/mom;
+ Double_t momz = mom*AliPID::ParticleCharge(j);
+ time[j]+=(recL-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(momz*momz+mass*mass)/momz;
+ //time[j]+=(recL-trackPos[3][0])/kSpeedOfLight*TMath::Sqrt(mom*mom+mass*mass)/mom;
}
AliTOFtrack *trackTOFout = new AliTOFtrack(*t);
}
}
- // Fill the track residual histograms.
- FillResiduals(trackTOFout,c,kFALSE);
+ // Fill the track residual histograms and update track only if in the first two step (0 and 1)
+ if(mLastStep < 2){
+ FillResiduals(trackTOFout,c,kFALSE);
- t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
- t->SetIntegratedLength(recL);
- t->SetIntegratedTimes(time);
- t->SetTOFLabel(tlab);
+ t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
+// don't update old structure with TOF info
+// t->SetIntegratedLength(recL);
+// t->SetIntegratedTimes(time);
+// t->SetTOFLabel(tlab);
+ // add tof cluster to the track also for step 2
+ AliESDTOFCluster* esdTOFCl = GetESDTOFCluster(idclus);
+ esdTOFCl->Update(t->GetID(),mindistY,mindist,mindistZ,recL,time);
+ t->AddTOFcluster(esdTOFCl->GetESDID());
+ /* RS?
+ if(idclus < 20000){
+ fClusterESD[idclus]->Update(t->GetID(),mindistY,mindist,mindistZ,recL,time);//x,y,z -> tracking RF
+
+ t->AddTOFcluster(idclus);
+ }
+ else{
+ AliInfo("Too many TOF clusters matched with tracks (> 20000)");
+ }
+ */
+ }
// Fill Reco-QA histos for Reconstruction
fHRecNClus->Fill(nc);
fHRecDist->Fill(mindist);
delete trackTOFout;
}
+
for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii];
delete [] clind;
AliInfo(Form("Number of clusters: %d",nc));
+ fN = 0;
+ fNTOFmatched = 0;
+
for (Int_t i=0; i<nc; i++) {
AliTOFcluster *c=(AliTOFcluster*)clusters->UncheckedAt(i);
//PH fClusters[i]=new AliTOFcluster(*c); fN++;
fClusters[i]=c; fN++;
-
+ c->SetESDID(-1);
// Fill Digits QA histos
Int_t isector = c->GetDetInd(0);
Float_t time =(AliTOFGeometry::TdcBinWidth()*c->GetTDC())*1E-3; // in ns
Float_t tot = (AliTOFGeometry::TdcBinWidth()*c->GetToT())*1E-3;//in ns
-
+
+ /* RS?
+ Int_t ind[5];
+ ind[0]=isector;
+ ind[1]=iplate;
+ ind[2]=istrip;
+ ind[3]=ipadZ;
+ ind[4]=ipadX;
+ Int_t calindex = AliTOFGeometry::GetIndex(ind);
+ Int_t tofLabels[3]={c->GetLabel(0),c->GetLabel(1),c->GetLabel(2)};
+ */
Int_t stripOffset = 0;
switch (iplate) {
case 0:
fHDigClusTime->Fill(time);
fHDigClusToT->Fill(tot);
+ fNTOFmatched++; // RS: Actually number of clusters
+ /* RS?
+ if(fNTOFmatched < 20000){
+ fHit[fNTOFmatched] = new AliESDTOFHit(AliTOFGeometry::TdcBinWidth()*c->GetTDC(),
+ AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW(),
+ AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3,
+ calindex,tofLabels,c->GetL0L1Latency(),
+ c->GetDeltaBC(),i,c->GetZ(),c->GetR(),c->GetPhi());
+ fNTOFmatched++;
+ }
+ */
}
-
return 0;
}
//_________________________________________________________________________
//PH delete fClusters[i];
fClusters[i] = 0x0;
}
+ /* RS
+ for(Int_t i=0; i< 20000;i++){
+ if(fClusterESD[i]){
+ delete fClusterESD[i];
+ fClusterESD[i] = NULL;
+ }
+ if(fHit[i]){
+ delete fHit[i];
+ fHit[i] = NULL;
+ }
+ }
+ */
fN=0;
+ fNTOFmatched = 0;
}
//_________________________________________________________________________
for (Int_t i=0; i<fN; ++i) arr->Add(fClusters[i]);
}
-//_________________________________________________________________________
+//_________________________________________________________________________
+AliESDTOFCluster* AliTOFtracker::GetESDTOFCluster(int clID)
+{
+ // get ESDTOFcluster corresponding to fClusters[clID]. If the original cluster
+ // was not stored yet in the ESD, first do this
+ AliTOFcluster *c = fClusters[clID];
+ AliESDTOFCluster *clESD = 0;
+ int esdID = c->GetESDID(); // was this cluster already stored in the ESD clusters?
+ TClonesArray* esdTOFClArr = fESDEv->GetESDTOFClusters();
+ if (esdID<0) { // cluster was not stored yet, do this
+ esdID = esdTOFClArr->GetEntriesFast();
+ c->SetESDID(esdID);
+ // first store the hits of the cluster
+ TClonesArray* esdTOFHitArr = fESDEv->GetESDTOFHits();
+ int nh = esdTOFHitArr->GetEntriesFast();
+ Int_t tofLabels[3]={c->GetLabel(0),c->GetLabel(1),c->GetLabel(2)};
+ Int_t ind[5] = {c->GetDetInd(0), c->GetDetInd(1), c->GetDetInd(2), c->GetDetInd(3), c->GetDetInd(4) };
+ Int_t calindex = AliTOFGeometry::GetIndex(ind);
+ /*AliESDTOFHit* esdHit = */
+ new ( (*esdTOFHitArr)[nh] )
+ AliESDTOFHit( AliTOFGeometry::TdcBinWidth()*c->GetTDC(),
+ AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW(),
+ AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3,
+ calindex,tofLabels,c->GetL0L1Latency(),
+ c->GetDeltaBC(),esdID,c->GetZ(),c->GetR(),c->GetPhi());
+ //
+ clESD = new( (*esdTOFClArr)[esdID] ) AliESDTOFCluster( clID );
+ clESD->SetEvent(fESDEv);
+ clESD->SetStatus( c->GetStatus() );
+ clESD->SetESDID(esdID);
+ //
+ // register hits in the cluster
+ clESD->AddESDTOFHitIndex(nh);
+ }
+ else clESD = (AliESDTOFCluster*)esdTOFClArr->At(esdID); // cluster is aready stored in the ESD
+ //
+ return clESD;
+ //
+}