#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(15000)),
+ fSeeds(new TObjArray(100)),
+ fTOFtrackPoints(new TObjArray(10)),
fHDigClusMap(0x0),
fHDigNClus(0x0),
fHDigClusTime(0x0),
fTime(-1.),
fExpTimePi(-1.),
fExpTimeKa(-1.),
- fExpTimePr(-1.)
- {
+ fExpTimePr(-1.),
+ fNTOFmatched(0)
+{
//AliTOFtracker main Ctor
-
- // Gettimg the geometry
- fGeom= new AliTOFGeometry();
- InitCheckHists();
+ for (Int_t ii=0; ii<kMaxCluster; ii++) fClusters[ii]=0x0;
+
+ // Getting the geometry
+ fGeom = new AliTOFGeometry();
+ /* RS?
+ for(Int_t i=0; i< 20000;i++){
+ fClusterESD[i] = NULL;
+ fHit[i] = NULL;
+ }
+ */
+ InitCheckHists();
}
//_____________________________________________________________________________
delete fSeeds;
fSeeds=0x0;
}
+ if (fTOFtrackPoints){
+ fTOFtrackPoints->Delete();
+ delete fTOFtrackPoints;
+ fTOFtrackPoints=0x0;
+ }
+
+ 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;
+ }
+ }
+ */
}
//_____________________________________________________________________________
//
// 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
- if (!fSeeds)
- fSeeds = new TObjArray(fNseeds);
- 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++) {
+ // 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);
//if(seed->GetTOFsignal()>0){
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);
+ Double_t time[AliPID::kSPECIESC]; seed->GetIntegratedTimes(time,AliPID::kSPECIESC);
t->SetIntegratedTimes(time);
Double_t length = seed->GetIntegratedLength();
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)",
+ 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->GetTOFsignalDx(),
t->GetTOFCalChannel(),
t->GetTOFcluster(),
- t->GetIntegratedLength(),
- time[0], time[1], time[2], time[3], time[4]
- )
- );
+ t->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
// fPid->MakePID(event,timeZero);
- fSeeds->Clear(); delete fSeeds; fSeeds=0;
- fTracks->Delete();
+ fSeeds->Clear();
+ //fTracks->Delete();
+ fTracks->Clear();
return 0;
}
//prepare the set of ESD tracks to be matched to clusters in TOF
Int_t seedsTOF1=0;
+ Int_t seedsTOF3=0;
Int_t seedsTOF2=0;
TClonesArray &aTOFTrack = *fTracks;
AliTOFtrack *track = new AliTOFtrack(*t); // New
Float_t x = (Float_t)track->GetX(); //New
- // TRD 'good' tracks, already propagated at 371 cm
- if ( ( (t->GetStatus()&AliESDtrack::kTRDout)!=0 ) &&
- ( x >= AliTOFGeometry::Rmin() ) ) {
- if ( track->PropagateToInnerTOF() ) {
+ // TRD 'good' tracks
+ if ( ( (t->GetStatus()&AliESDtrack::kTRDout)!=0 ) ) {
- AliDebug(1,Form(" TRD propagated track till rho = %fcm."
- " And then the track has been propagated till rho = %fcm.",
- x, (Float_t)track->GetX()));
+ AliDebug(1,Form(" Before propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
+
+ // TRD 'good' tracks, already propagated at 371 cm
+ if( x >= AliTOFGeometry::Rmin() ) {
+
+ if ( track->PropagateToInnerTOF() ) {
+
+ AliDebug(1,Form(" TRD propagated track till rho = %fcm."
+ " And then the track has been propagated till rho = %fcm.",
+ x, (Float_t)track->GetX()));
+
+ track->SetSeedIndex(i);
+ t->UpdateTrackParams(track,AliESDtrack::kTOFin);
+ new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
+ fNseedsTOF++;
+ seedsTOF1++;
+
+ AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
+ }
+ delete track;
- track->SetSeedIndex(i);
- t->UpdateTrackParams(track,AliESDtrack::kTOFin);
- new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
- fNseedsTOF++;
- seedsTOF1++;
}
- delete track;
+ else { // TRD 'good' tracks, propagated rho<371cm
+
+ if ( track->PropagateToInnerTOF() ) {
+
+ AliDebug(1,Form(" TRD propagated track till rho = %fcm."
+ " And then the track has been propagated till rho = %fcm.",
+ x, (Float_t)track->GetX()));
+
+ track->SetSeedIndex(i);
+ t->UpdateTrackParams(track,AliESDtrack::kTOFin);
+ new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
+ fNseedsTOF++;
+ seedsTOF3++;
+
+ AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
+ }
+ delete track;
+
+ }
+ //delete track;
}
- // Propagate the rest of TPCbp
- else {
+ else { // Propagate the rest of TPCbp
+
+ AliDebug(1,Form(" Before propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
+
if ( track->PropagateToInnerTOF() ) {
AliDebug(1,Form(" TPC propagated track till rho = %fcm."
new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
fNseedsTOF++;
seedsTOF2++;
+
+ AliDebug(1,Form(" After propagation till inner TOF radius, ESDtrackLength=%f, TOFtrackLength=%f",t->GetIntegratedLength(),track->GetIntegratedLength()));
}
delete track;
}
}
- AliInfo(Form("Number of TOF seeds = %d (Type 1 = %d, Type 2 = %d)",fNseedsTOF,seedsTOF1,seedsTOF2));
+ AliInfo(Form("Number of TOF seeds = %d (kTRDout371 = %d, kTRDoutLess371 = %d, !kTRDout = %d)",fNseedsTOF,seedsTOF1,seedsTOF3,seedsTOF2));
// Sort according uncertainties on track position
fTracks->Sort();
}
-//_________________________________________________________________________
-void AliTOFtracker::MatchTracks( Bool_t mLastStep){
+//_________________________________________________________________________
+void AliTOFtracker::MatchTracks( Int_t mLastStep){
// Parameters used/regulating the reconstruction
- static Float_t corrLen=0.75;
- static Float_t detDepth=15.3;
+ //static Float_t corrLen=0.;//0.75;
+ static Float_t detDepth=18.;
static Float_t padDepth=0.5;
const Float_t kSpeedOfLight= 2.99792458e-2; // speed of light [cm/ps]
- const Float_t kTimeOffset = 32.; // time offset for tracking algorithm [ps]
+ const Float_t kTimeOffset = 0.; // time offset for tracking algorithm [ps]
Float_t dY=AliTOFGeometry::XPad();
Float_t dZ=AliTOFGeometry::ZPad();
Float_t sensRadius = fkRecoParam->GetSensRadius();
Float_t stepSize = fkRecoParam->GetStepSize();
- Float_t scaleFact = fkRecoParam->GetWindowScaleFact();
+ Float_t scaleFact = fkRecoParam->GetWindowScaleFact();
Float_t dyMax=fkRecoParam->GetWindowSizeMaxY();
Float_t dzMax=fkRecoParam->GetWindowSizeMaxZ();
Float_t dCut=fkRecoParam->GetDistanceCut();
+ if (dCut==3. && fNseedsTOF<=10) {
+ dCut=10.;
+ 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));
// Get the number of propagation steps
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];
Int_t * clind = new Int_t[fN];
// Some init
- const Int_t kNfoundMax = 10000; // related to nSteps value
- Int_t index[kNfoundMax];
- Float_t dist[kNfoundMax];
- Float_t distZ[kNfoundMax];
- Float_t distY[kNfoundMax]; // delta(rhoXphi) // AdC
- Float_t cxpos[kNfoundMax];
- Float_t crecL[kNfoundMax];
const Int_t kNclusterMax = 1000; // related to fN value
- TGeoHMatrix global[kNclusterMax];
-
+ TGeoHMatrix global[kNclusterMax];
+
//The matching loop
for (Int_t iseed=0; iseed<fNseedsTOF; iseed++) {
- for (Int_t ii=0; ii<kNfoundMax; ii++) {
- index[ii] = -1;
- dist[ii] = 9999.;
- distZ[ii] = 9999.;
- distY[ii] = 9999.;
- cxpos[ii] = 9999.;
- crecL[ii] = 0.;
- }
+ fTOFtrackPoints->Delete();
+
for (Int_t ii=0; ii<kNclusterMax; ii++)
global[ii] = 0x0;
-
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;
- AliTOFtrack *trackTOFin =new AliTOFtrack(*track);
+ if ( ((t->GetStatus()&AliESDtrack::kTOFout)!=0 ) && mLastStep < 2) continue;
+ AliTOFtrack *trackTOFin = new AliTOFtrack(*track);
// Determine a window around the track
Double_t x,par[5];
Double_t z=par[1];
//upper limit on window's size.
-
- if(dz> dzMax) dz=dzMax;
- if(dphi*sensRadius> dyMax) dphi=dyMax/sensRadius;
+ if (dz> dzMax) dz=dzMax;
+ if (dphi*sensRadius> dyMax) dphi=dyMax/sensRadius;
- Int_t nc=0;
-
// find the clusters in the window of the track
-
+ Int_t nc=0;
for (Int_t k=FindClusterIndex(z-dz); k<fN; k++) {
if (nc>=kNclusterMax) {
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
if (trackTOFin->AliExternalTrackParam::GetPredictedChi2(p,cov2) > maxChi2)continue;
clind[nc] = k;
- Char_t path[100];
+ Char_t path[200];
Int_t ind[5];
ind[0]=c->GetDetInd(0);
ind[1]=c->GetDetInd(1);
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;
for( Int_t istep=0; istep<nSteps; istep++){
- Float_t xs=AliTOFGeometry::RinTOF()+istep*0.1;
- Double_t ymax=xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
+ // First of all, propagate the track...
+ Float_t xs = AliTOFGeometry::RinTOF()+istep*stepSize;
+ if (!(trackTOFin->PropagateTo(xs))) break;
- Bool_t skip=kFALSE;
- Double_t ysect=trackTOFin->GetYat(xs,skip);
- if (skip) break;
+ // ...and then, if necessary, rotate the track
+ Double_t ymax = xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
+ Double_t ysect = trackTOFin->GetY();
if (ysect > ymax) {
- if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
- break;
- }
+ if (!(trackTOFin->Rotate(AliTOFGeometry::GetAlpha()))) break;
} else if (ysect <-ymax) {
- if (!trackTOFin->Rotate(-AliTOFGeometry::GetAlpha())) {
- break;
- }
- }
-
- if(!trackTOFin->PropagateTo(xs)) {
- break;
+ if (!(trackTOFin->Rotate(-AliTOFGeometry::GetAlpha()))) break;
}
nStepsDone++;
+ AliDebug(3,Form(" current step %d (%d) - nStepsDone=%d",istep,nSteps,nStepsDone));
// store the running point (Globalrf) - fine propagation
Double_t r[3];
trackTOFin->GetXYZ(r);
- trackPos[0][istep]= (Float_t) r[0];
- trackPos[1][istep]= (Float_t) r[1];
- trackPos[2][istep]= (Float_t) r[2];
- trackPos[3][istep]= trackTOFin->GetIntegratedLength();
+ trackPos[0][nStepsDone-1]= (Float_t) r[0];
+ trackPos[1][nStepsDone-1]= (Float_t) r[1];
+ trackPos[2][nStepsDone-1]= (Float_t) r[2];
+ trackPos[3][nStepsDone-1]= trackTOFin->GetIntegratedLength();
}
+#if 0
+ /*****************/
+ /**** OLD CODE ***/
+ /*****************/
+
Int_t nfound = 0;
Bool_t accept = kFALSE;
Bool_t isInside = kFALSE;
for (Int_t istep=0; istep<nStepsDone; istep++) {
- if (nfound>=kNfoundMax) {
- AliWarning("No more track positions can be stored! Please, increase the corresponding vectors size.");
- break;
- }
-
Float_t ctrackPos[3];
ctrackPos[0] = trackPos[0][istep];
ctrackPos[1] = trackPos[1][istep];
Float_t dist3d[3];
accept = kFALSE;
for (Int_t i=0; i<nc; i++) {
- isInside = fGeom->IsInsideThePad(global[i],ctrackPos,dist3d);
+ isInside = fGeom->IsInsideThePad((TGeoHMatrix*)(&global[i]),ctrackPos,dist3d);
if ( mLastStep ) {
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;
}
if (accept) {
- dist[nfound] = TMath::Sqrt(dist3d[0]*dist3d[0] +
- dist3d[1]*dist3d[1] +
- dist3d[2]*dist3d[2]);
- AliDebug(2,Form(" dist3dLoc[0] = %f, dist3dLoc[1] = %f, dist3dLoc[2] = %f ",
- dist3d[0],dist3d[1],dist3d[2]));
- distZ[nfound] = dist3d[2]; // Z distance in the RF of the
- // hit pad closest to the
- // reconstructed track
- distY[nfound] = dist3d[0]; // X distance in the RF of the
- // hit pad closest to the
- // reconstructed track
- // It corresponds to Y coordinate
- // in tracking RF
-
-
- AliDebug(2,Form(" dist3dLoc[0] = %f --- distY[%d] = %f",
- dist3d[0],nfound,distY[nfound]));
- AliDebug(2,Form(" dist3dLoc[2] = %f --- distZ[%d] = %f",
- dist3d[2],nfound,distZ[nfound]));
-
-
- crecL[nfound] = trackPos[3][istep];
- index[nfound] = clind[i]; // store cluster id
- cxpos[nfound] = AliTOFGeometry::RinTOF()+istep*0.1; //store prop.radius
+ fTOFtrackPoints->AddLast(new AliTOFtrackPoint(clind[i],
+ TMath::Sqrt(dist3d[0]*dist3d[0] + dist3d[1]*dist3d[1] + dist3d[2]*dist3d[2]),
+ dist3d[2],dist3d[0],dist3d[1],
+ AliTOFGeometry::RinTOF()+istep*stepSize,trackPos[3][istep]));
+
+ 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
if(accept &&!mLastStep)break;
} //end for on the steps
- AliDebug(1,Form(" Number of track points for the track number %d: %d",iseed,nfound));
+ /*****************/
+ /**** OLD CODE ***/
+ /*****************/
+#endif
+
+ 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;
+ for (Int_t istep=0; istep<nStepsDone; istep++) {
+
+ Bool_t gotInsideCluster = kFALSE;
+ Int_t trackInsideCluster = -1;
+
+ Float_t ctrackPos[3];
+ ctrackPos[0] = trackPos[0][istep];
+ ctrackPos[1] = trackPos[1][istep];
+ ctrackPos[2] = trackPos[2][istep];
+
+ //now see whether the track matches any of the TOF clusters
+
+ Float_t dist3d[3]={0.,0.,0.};
+ accept = kFALSE;
+ for (Int_t i=0; i<nc; i++) {
+
+ // ***** NEW *****
+ /* check whether track was inside another cluster
+ * and in case inhibit this cluster.
+ * 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(3,Form(" A - istep=%d ~ %d %d ~ nfound=%d",istep,trackInsideCluster,i,nfound));
+ continue;
+ }
+ 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.;
+ isInside = fGeom->IsInsideThePad((TGeoHMatrix*)(&global[i]),ctrackPos,dist3d);
+
+ // ***** NEW *****
+ /* if track is inside this cluster set flags which will then
+ * inhibit to add track points for the other clusters */
+ if (isInside) {
+ gotInsideCluster = kTRUE;
+ trackInsideCluster = i;
+ }
+
+ if ( mLastStep ) {
+ 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(3," I am in the case mLastStep==kTRUE ");
+ }
+
+ //***** NEW *****
+ /* add point everytime that:
+ * - the track is inside the cluster
+ * - the track got inside the cluster, even when it eventually exited the cluster
+ * - the tracks is within dCut from the cluster
+ */
+ if (accept || isInside || gotInsideCluster) {
+
+ fTOFtrackPoints->AddLast(new AliTOFtrackPoint(clind[i],
+ TMath::Sqrt(dist3d[0]*dist3d[0] + dist3d[1]*dist3d[1] + dist3d[2]*dist3d[2]),
+ 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]));
+ 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
+ * are inhibited */
+ // if(accept &&!mLastStep)break;
+
+ }//end if accept
+
+ } //end for on the clusters
+
+ // ***** NEW *****
+ /* do not break loop in any case
+ * if the track got inside a cluster all other clusters
+ * are inhibited but we want to go on adding track points */
+ // if(accept &&!mLastStep)break;
+
+ } //end for on the steps
+ if(nc) delete[] isClusterMatchable;
if (nfound == 0 ) {
+ AliDebug(1,Form("No track points for the track number %d",iseed));
fnunmatch++;
delete trackTOFin;
continue;
}
- fnmatch++;
+ 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.
Float_t mindist=1000.;
Float_t mindistZ=0.;
Float_t mindistY=0.;
- for (Int_t iclus= 0; iclus<nfound;iclus++){
- if (dist[iclus]< mindist){
- mindist = dist[iclus];
- mindistZ = distZ[iclus]; // Z distance in the RF of the hit
- // pad closest to the reconstructed
- // track
- mindistY = distY[iclus]; // Y distance in the RF of the hit
- // pad closest to the reconstructed
- // track
- xpos = cxpos[iclus];
- idclus =index[iclus];
- recL=crecL[iclus]+corrLen*0.5;
+ Float_t mindistX=stepSize;
+ for (Int_t iclus= 0; iclus<nfound;iclus++) {
+ AliTOFtrackPoint *matchableTOFcluster = (AliTOFtrackPoint*)fTOFtrackPoints->At(iclus);
+ //if ( matchableTOFcluster->Distance()<mindist ) {
+ if ( TMath::Abs(matchableTOFcluster->DistanceX())<TMath::Abs(mindistX) &&
+ TMath::Abs(matchableTOFcluster->DistanceX())<=stepSize ) {
+ mindist = matchableTOFcluster->Distance();
+ mindistZ = matchableTOFcluster->DistanceZ(); // Z distance in the
+ // RF of the hit pad
+ // closest to the
+ // reconstructed
+ // track
+ mindistY = matchableTOFcluster->DistanceY(); // Y distance in the
+ // RF of the hit pad
+ // closest to the
+ // reconstructed
+ // track
+ mindistX = matchableTOFcluster->DistanceX(); // X distance in the
+ // RF of the hit pad
+ // closest to the
+ // reconstructed
+ // track
+ xpos = matchableTOFcluster->PropRadius();
+ idclus = matchableTOFcluster->Index();
+ recL = matchableTOFcluster->Length();// + corrLen*0.5;
+
+ 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(" %d - not matched --- but idclus=%d, trackId=%d, trackLab=%d",iseed,
+ idclus,track->GetSeedIndex(),track->GetLabel()));
+ idclus=-1;
+ }
+
+ if (idclus==-1) {
+ AliDebug(1,Form("Reconstructed track %d doesn't match any TOF cluster", iseed));
+ fnunmatch++;
+ delete trackTOFin;
+ continue;
}
+ AliDebug(1,Form(" %d - matched",iseed));
+
+ fnmatch++;
AliTOFcluster *c=fClusters[idclus];
- /*
- Float_t tiltangle = AliTOFGeometry::GetAngles(c->GetDetInd(1),c->GetDetInd(2))*TMath::DegToRad();
- Float_t localCheck=-mindistZ;
- localCheck/=TMath::Cos(tiltangle); // Z (tracking/ALICE RF) component of
- // the distance between the
- // reconstructed track and the
- // TOF closest cluster
- */
- 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()),
c->Use();
// Track length correction for matching Step 2
-
- if(mLastStep){
- Float_t rc=TMath::Sqrt(c->GetR()*c->GetR() + c->GetZ()*c->GetZ());
- Float_t rt=TMath::Sqrt(trackPos[0][70]*trackPos[0][70]
- +trackPos[1][70]*trackPos[1][70]
- +trackPos[2][70]*trackPos[2][70]);
- Float_t dlt=rc-rt;
+ /*
+ if (mLastStep) {
+ Float_t rc = TMath::Sqrt(c->GetR()*c->GetR() + c->GetZ()*c->GetZ());
+ Float_t rt = TMath::Sqrt(trackPos[0][70]*trackPos[0][70]
+ +trackPos[1][70]*trackPos[1][70]
+ +trackPos[2][70]*trackPos[2][70]);
+ Float_t dlt=rc-rt;
recL=trackPos[3][70]+dlt;
- }
-
+ }
+ */
if (
(c->GetLabel(0)==TMath::Abs(trackTOFin->GetLabel()))
||
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];
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->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);
- trackTOFout->PropagateTo(xpos);
+ if (!(trackTOFout->PropagateTo(xpos))) {
+ delete trackTOFout;
+ continue;
+ }
- // Fill the track residual histograms.
- FillResiduals(trackTOFout,c,kFALSE);
+ // If necessary, rotate the track
+ Double_t yATxposMax=xpos*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
+ Double_t yATxpos=trackTOFout->GetY();
+ if (yATxpos > yATxposMax) {
+ if (!(trackTOFout->Rotate(AliTOFGeometry::GetAlpha()))) {
+ delete trackTOFout;
+ continue;
+ }
+ } else if (yATxpos < -yATxposMax) {
+ if (!(trackTOFout->Rotate(-AliTOFGeometry::GetAlpha()))) {
+ delete trackTOFout;
+ continue;
+ }
+ }
- t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout);
- t->SetIntegratedLength(recL);
- t->SetIntegratedTimes(time);
- t->SetTOFLabel(tlab);
+ // 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);
+
+// 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);
- fHRecSigYVsP->Fill(mom,TMath::Sqrt(cov[0]));
- fHRecSigZVsP->Fill(mom,TMath::Sqrt(cov[2]));
+ if (cov[0]>=0.)
+ fHRecSigYVsP->Fill(mom,TMath::Sqrt(cov[0]));
+ else
+ fHRecSigYVsP->Fill(mom,-TMath::Sqrt(-cov[0]));
+ if (cov[2]>=0.)
+ fHRecSigZVsP->Fill(mom,TMath::Sqrt(cov[2]));
+ else
+ fHRecSigZVsP->Fill(mom,-TMath::Sqrt(-cov[2]));
fHRecSigYVsPWin->Fill(mom,dphi*sensRadius);
fHRecSigZVsPWin->Fill(mom,dz);
}
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;
+ //
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff