X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TOF%2FAliTOFtracker.cxx;h=0bb4892c04df725dbff422c0fbaf8e9607e7a3bf;hb=c687d49a98a03b68b28474105b41f8df28d86d21;hp=8badee5f05f865c5b51487470fd5eaa2c6457125;hpb=8a190ba28397d08a3826976c55dff231b8f86fb1;p=u%2Fmrichter%2FAliRoot.git diff --git a/TOF/AliTOFtracker.cxx b/TOF/AliTOFtracker.cxx index 8badee5f05f..0bb4892c04d 100644 --- a/TOF/AliTOFtracker.cxx +++ b/TOF/AliTOFtracker.cxx @@ -31,6 +31,7 @@ #include #include +#include #include #include #include @@ -39,11 +40,12 @@ #include "AliGeomManager.h" #include "AliESDtrack.h" #include "AliESDEvent.h" +#include "AliESDpid.h" #include "AliLog.h" #include "AliTrackPointArray.h" #include "AliCDBManager.h" -#include "AliTOFpidESD.h" +//#include "AliTOFpidESD.h" #include "AliTOFRecoParam.h" #include "AliTOFReconstructor.h" #include "AliTOFcluster.h" @@ -52,15 +54,15 @@ #include "AliTOFtrack.h" extern TGeoManager *gGeoManager; -extern TROOT *gROOT; +//extern TROOT *gROOT; + ClassImp(AliTOFtracker) //_____________________________________________________________________________ AliTOFtracker::AliTOFtracker(): - fRecoParam(0x0), + fkRecoParam(0x0), fGeom(0x0), - fPid(0x0), fN(0), fNseeds(0), fNseedsTOF(0), @@ -68,8 +70,10 @@ AliTOFtracker::AliTOFtracker(): fnbadmatch(0), fnunmatch(0), fnmatch(0), + fESDEv(0), fTracks(new TClonesArray("AliTOFtrack")), - fSeeds(new TClonesArray("AliESDtrack")), + fSeeds(new TObjArray(100)), + fTOFtrackPoints(new TObjArray(10)), fHDigClusMap(0x0), fHDigNClus(0x0), fHDigClusTime(0x0), @@ -86,14 +90,22 @@ AliTOFtracker::AliTOFtracker(): 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; iiGetCacheFlag())){ - delete fRecoParam; + delete fkRecoParam; } delete fGeom; - delete fPid; delete fHDigClusMap; delete fHDigNClus; delete fHDigClusTime; @@ -130,32 +141,70 @@ AliTOFtracker::~AliTOFtracker() { delete fSeeds; fSeeds=0x0; } + if (fTOFtrackPoints){ + fTOFtrackPoints->Delete(); + delete fTOFtrackPoints; + fTOFtrackPoints=0x0; + } + + for (Int_t ii=0; iiDelete(); + + /* 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; + } + } + */ } //_____________________________________________________________________________ -Int_t AliTOFtracker::PropagateBack(AliESDEvent* event) { +void AliTOFtracker::GetPidSettings(AliESDpid *esdPID) { + // + // Sets TOF resolution from RecoParams + // + if (fkRecoParam) + esdPID->GetTOFResponse().SetTimeResolution(fkRecoParam->GetTimeResolution()); + else + AliWarning("fkRecoParam not yet set; cannot set PID settings"); +} +//_____________________________________________________________________________ +Int_t AliTOFtracker::PropagateBack(AliESDEvent * const event) { // // 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"); - AliInfo("Initializing params for TOF... "); + fkRecoParam = AliTOFReconstructor::GetRecoParam(); // instantiate reco param from STEER... - fRecoParam = AliTOFReconstructor::GetRecoParam(); // instantiate reco param from STEER... - - if (fRecoParam == 0x0) { + if (fkRecoParam == 0x0) { AliFatal("No Reco Param found for TOF!!!"); } - //fRecoParam->Dump(); - //if(fRecoParam->GetApplyPbPbCuts())fRecoParam=fRecoParam->GetPbPbparam(); - //fRecoParam->PrintParameters(); - - Double_t parPID[2]; - parPID[0]=fRecoParam->GetTimeResolution(); - parPID[1]=fRecoParam->GetTimeNSigma(); - fPid=new AliTOFpidESD(parPID); - + //fkRecoParam->Dump(); + //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; @@ -167,74 +216,177 @@ Int_t AliTOFtracker::PropagateBack(AliESDEvent* event) { Int_t ntrk=event->GetNumberOfTracks(); fNseeds = ntrk; - TClonesArray &aESDTrack = *fSeeds; //Load ESD tracks into a local Array of ESD Seeds - - for (Int_t i=0; iGetTrack(i); - new(aESDTrack[i]) AliESDtrack(*t); + for (Int_t i=0; iAddLast(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); - AliInfo(Form("Number of matched tracks: %d",fnmatch)); - AliInfo(Form("Number of good matched tracks: %d",fngoodmatch)); - AliInfo(Form("Number of bad matched tracks: %d",fnbadmatch)); - - //Update the matched ESD tracks + //Third Step without kTOFout flag (just to update clusters) + MatchTracks(2); - for (Int_t i=0; iGetTrack(i); - AliESDtrack *seed =(AliESDtrack*)fSeeds->UncheckedAt(i); - if(seed->GetTOFsignal()>0){ - t->SetTOFsignal(seed->GetTOFsignal()); - t->SetTOFcluster(seed->GetTOFcluster()); - t->SetTOFsignalToT(seed->GetTOFsignalToT()); - t->SetTOFsignalRaw(seed->GetTOFsignalRaw()); - t->SetTOFsignalDz(seed->GetTOFsignalDz()); - t->SetTOFCalChannel(seed->GetTOFCalChannel()); - Int_t tlab[3]; seed->GetTOFLabel(tlab); - t->SetTOFLabel(tlab); - AliTOFtrack *track = new AliTOFtrack(*seed); - t->UpdateTrackParams(track,AliESDtrack::kTOFout); - delete track; - } + //RS? event->SetTOFcluster(fNTOFmatched,fClusterESD); + + if (fN==0) { + AliInfo("No TOF recPoints to be matched with reconstructed tracks"); + fSeeds->Clear(); + fTracks->Clear(); + return 0; } - //Handle Time Zero information - - Double_t timeZero=0.; - Double_t timeZeroMax=99999.; - Bool_t usetimeZero = fRecoParam->UseTimeZero(); - Bool_t timeZeroFromT0 = fRecoParam->GetTimeZerofromT0(); - Bool_t timeZeroFromTOF = fRecoParam->GetTimeZerofromTOF(); + AliInfo(Form("Number of matched tracks = %d (good = %d, bad = %d)",fnmatch,fngoodmatch,fnbadmatch)); - AliDebug(1,Form("Use Time Zero?: %d",usetimeZero)); - AliDebug(1,Form("Time Zero from T0? : %d",timeZeroFromT0)); - AliDebug(1,Form("Time Zero From TOF? : %d",timeZeroFromTOF)); + //Update the matched ESD tracks - if(usetimeZero){ - if(timeZeroFromT0){ - timeZero=GetTimeZerofromT0(event); + for (Int_t i=0; iGetTrack(i); + AliESDtrack *seed =(AliESDtrack*)fSeeds->At(i); + if ( (seed->GetStatus()&AliESDtrack::kTOFin)!=0 ) { + //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()); + Int_t tlab[3]; seed->GetTOFLabel(tlab); + //t->SetTOFLabel(tlab); + + 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); + AliDebug(3,Form(" distance=%f; residual in the pad reference frame: dX=%f, dZ=%f", info[0],info[1],info[2])); + + // Check done: + // by calling the AliESDtrack::UpdateTrackParams, + // the current track parameters are changed + // and it could cause refit problems. + // We need to update only the following track parameters: + // the track length and expected times. + // Removed AliESDtrack::UpdateTrackParams call + // Called AliESDtrack::SetIntegratedTimes(...) and + // AliESDtrack::SetIntegratedLength() routines. + /* + AliTOFtrack *track = new AliTOFtrack(*seed); + t->UpdateTrackParams(track,AliESDtrack::kTOFout); // to be checked - AdC + delete track; + Double_t time[AliPID::kSPECIESC]; t->GetIntegratedTimes(time); + */ + + 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(3,Form(" p1: %f(%f), p2: %f(%f), p3: %f(%f)", + p1B,p1A, + p2B,p2A, + p3B,p3A)); + 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)" + " cov13: %f(%f), cov14: %f(%f), cov15: %f(%f)", + covB[0],covA[0], + covB[1],covA[1], + covB[2],covA[2], + covB[3],covA[3], + covB[4],covA[4], + covB[5],covA[5], + covB[6],covA[6], + covB[7],covA[7], + covB[8],covA[8], + covB[9],covA[9], + covB[10],covA[10], + covB[11],covA[11], + covB[12],covA[12], + covB[13],covA[13], + covB[14],covA[14] + )); + AliDebug(2,Form(" TOF params: %6d %f %f %f %f %f %6d %3d %f", + i, + 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])); + } } - if(timeZeroFromTOF && (timeZero>timeZeroMax || !timeZeroFromT0)){ - timeZero=GetTimeZerofromTOF(event); + } + /* RS? + if(fNTOFmatched){ + Int_t *matchmap = new Int_t[fNTOFmatched]; + event->SetTOFcluster(fNTOFmatched,fClusterESD,matchmap); + for (Int_t i=0; iGetTrack(i); + t->ReMapTOFcluster(fNTOFmatched,matchmap); } + + delete[] matchmap; } - AliDebug(2,Form("time Zero used in PID: %f",timeZero)); + */ + //Make TOF PID - fPid->MakePID(event,timeZero); + // Now done in AliESDpid + // fPid->MakePID(event,timeZero); fSeeds->Clear(); + //fTracks->Delete(); fTracks->Clear(); return 0; @@ -244,73 +396,128 @@ void AliTOFtracker::CollectESD() { //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; for (Int_t i=0; iUncheckedAt(i); + AliESDtrack *t =(AliESDtrack*)fSeeds->At(i); if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue; - // TRD 'good' tracks, already propagated at 372 cm - AliTOFtrack *track = new AliTOFtrack(*t); // New - Double_t x = track->GetX(); //New - if (((t->GetStatus()&AliESDtrack::kTRDout)!=0 ) && - ( x >= AliTOFGeometry::RinTOF()) ){ - track->SetSeedIndex(i); - t->UpdateTrackParams(track,AliESDtrack::kTOFout); - new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track); - fNseedsTOF++; - seedsTOF1++; - delete track; + Float_t x = (Float_t)track->GetX(); //New + + // TRD 'good' tracks + if ( ( (t->GetStatus()&AliESDtrack::kTRDout)!=0 ) ) { + + 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; + + } + 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 { // 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." + " And then the track has been propagated till rho = %fcm.", + x, (Float_t)track->GetX())); - else { - if(track->PropagateToInnerTOF()){ track->SetSeedIndex(i); - t->UpdateTrackParams(track,AliESDtrack::kTOFout); + t->UpdateTrackParams(track,AliESDtrack::kTOFin); 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 %i",fNseedsTOF)); - AliInfo(Form("Number of TOF seeds Type 1 %i",seedsTOF1)); - AliInfo(Form("Number of TOF seeds Type 2 %i",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 = 0.; // time offset for tracking algorithm [ps] + Float_t dY=AliTOFGeometry::XPad(); Float_t dZ=AliTOFGeometry::ZPad(); - Float_t sensRadius = fRecoParam->GetSensRadius(); - Float_t stepSize = fRecoParam->GetStepSize(); - Float_t scaleFact = fRecoParam->GetWindowScaleFact(); - Float_t dyMax=fRecoParam->GetWindowSizeMaxY(); - Float_t dzMax=fRecoParam->GetWindowSizeMaxZ(); - Float_t dCut=fRecoParam->GetDistanceCut(); - Double_t maxChi2=fRecoParam->GetMaxChi2TRD(); - Bool_t timeWalkCorr = fRecoParam->GetTimeWalkCorr(); + Float_t sensRadius = fkRecoParam->GetSensRadius(); + Float_t stepSize = fkRecoParam->GetStepSize(); + 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)); @@ -320,48 +527,55 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ AliDebug(1,Form("TOF Max Chi2: %f",maxChi2)); AliDebug(1,Form("Time Walk Correction? : %d",timeWalkCorr)); } - //Match ESD tracks to clusters in TOF + //Match ESD tracks to clusters in TOF // Get the number of propagation steps - Int_t nSteps=(Int_t)(detDepth/stepSize); + AliDebug(1,Form(" Number of steps to be done %d",nSteps)); - //PH Arrays (moved outside of the loop) + 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]; Int_t * clind = new Int_t[fN]; + // Some init + const Int_t kNclusterMax = 1000; // related to fN value + TGeoHMatrix global[kNclusterMax]; + + //The matching loop for (Int_t iseed=0; iseedDelete(); + + for (Int_t ii=0; iiUncheckedAt(iseed); - AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(track->GetSeedIndex()); - if(t->GetTOFsignal()>0. ) continue; - AliTOFtrack *trackTOFin =new AliTOFtrack(*track); - - // Some init - - Int_t index[10000]; - Float_t dist[10000]; - Float_t distZ[10000]; - Float_t cxpos[10000]; - Float_t crecL[10000]; - TGeoHMatrix global[1000]; - - // Determine a window around the track + AliESDtrack *t =(AliESDtrack*)fSeeds->At(track->GetSeedIndex()); + //if ( t->GetTOFsignal()>0. ) continue; + 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]; trackTOFin->GetExternalParameters(x,par); Double_t cov[15]; trackTOFin->GetExternalCovariance(cov); + if (cov[0]<0. || cov[2]<0.) { + AliWarning(Form("Very strange track (%d)! At least one of its covariance matrix diagonal elements is negative!",iseed)); + //delete trackTOFin; + //continue; + } + Double_t dphi= scaleFact* - ((5*TMath::Sqrt(cov[0]) + 0.5*dY + 2.5*TMath::Abs(par[2]))/sensRadius); + ((5*TMath::Sqrt(TMath::Abs(cov[0])) + 0.5*dY + 2.5*TMath::Abs(par[2]))/sensRadius); Double_t dz= scaleFact* - (5*TMath::Sqrt(cov[2]) + 0.5*dZ + 2.5*TMath::Abs(par[3])); + (5*TMath::Sqrt(TMath::Abs(cov[2])) + 0.5*dZ + 2.5*TMath::Abs(par[3])); Double_t phi=TMath::ATan2(par[0],x) + trackTOFin->GetAlpha(); if (phi<-TMath::Pi())phi+=2*TMath::Pi(); @@ -369,24 +583,25 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ 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=kNclusterMax) { + AliWarning("No more matchable clusters can be stored! Please, increase the corresponding vectors size."); + break; + } + 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 + AliDebug(1,"Cluster in channel declared bad!"); + continue; // skip bad channels as declared in OCDB } Double_t dph=TMath::Abs(c->GetPhi()-phi); @@ -399,7 +614,7 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ 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); @@ -412,92 +627,234 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ 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; istepPropagateTo(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; + Bool_t isInside = kFALSE; for (Int_t istep=0; istepIsInsideThePad(global[i],ctrackPos,dist3d); - - if( mLastStep){ - Float_t xLoc=dist3d[0]; - Float_t rLoc=TMath::Sqrt(dist3d[1]*dist3d[1]+dist3d[2]*dist3d[2]); - accept = (TMath::Abs(xLoc)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)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 + } //end for on the clusters if(accept &&!mLastStep)break; } //end for on the steps + /*****************/ + /**** 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; iIsInsideThePad((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)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;ispGetIntegratedTimesOld(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. @@ -506,20 +863,59 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ Float_t xpos=0.; Float_t mindist=1000.; Float_t mindistZ=0.; - for (Int_t iclus= 0; iclusAt(iclus); + //if ( matchableTOFcluster->Distance()DistanceX())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]; - AliDebug(2, Form("%7i %7i %10i %10i %10i %10i %7i", + AliDebug(3, Form("%7d %7d %10d %10d %10d %10d %7d", iseed, fnmatch-1, TMath::Abs(trackTOFin->GetLabel()), @@ -529,16 +925,16 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ 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())) || @@ -548,13 +944,13 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ ) { fngoodmatch++; - AliDebug(2,Form(" track label good %5i",trackTOFin->GetLabel())); + AliDebug(2,Form(" track label good %5d",trackTOFin->GetLabel())); } - else{ + else { fnbadmatch++; - AliDebug(2,Form(" track label bad %5i",trackTOFin->GetLabel())); + AliDebug(2,Form(" track label bad %5d",trackTOFin->GetLabel())); } @@ -562,11 +958,20 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ // Store quantities to be used in the TOF Calibration Float_t tToT=AliTOFGeometry::ToTBinWidth()*c->GetToT()*1E-3; // in ns - t->SetTOFsignalToT(tToT); - Float_t rawTime=AliTOFGeometry::TdcBinWidth()*c->GetTDCRAW()+32; // RAW time,in ps - t->SetTOFsignalRaw(rawTime); - t->SetTOFsignalDz(mindistZ); - AliDebug(2,Form(" Setting TOF raw time: %f, z distance: %f time: %f = ",rawTime,mindistZ)); +// 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()); + + Float_t info[10] = {mindist,mindistY,mindistZ, + 0.,0.,0.,0.,0.,0.,0.}; + t->SetTOFInfo(info); + 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[0]=c->GetDetInd(0); ind[1]=c->GetDetInd(1); @@ -574,50 +979,104 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ 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 %i = ",c->GetTDC())); - Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+32; // in ps - AliDebug(2,Form(" tof time of the matched track: %f = ",tof)); + AliDebug(3,Form(" tdc time of the matched track %6d = ",c->GetTDC())); + Double_t tof=AliTOFGeometry::TdcBinWidth()*c->GetTDC()+kTimeOffset; // in ps + 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(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); + Double_t time[AliPID::kSPECIESC]; + // read from old structure (the one used by TPC in reco) + for(Int_t isp=0;ispGetIntegratedTimesOld(isp); // in ps + } Double_t mom=t->GetP(); - for(Int_t j=0;j %f", iseed,mom)); + for (Int_t j=0;jPropagateTo(xpos); - t->UpdateTrackParams(trackTOFout,AliESDtrack::kTOFout); - t->SetIntegratedLength(recL); - t->SetIntegratedTimes(time); - t->SetTOFLabel(tlab); + if (!(trackTOFout->PropagateTo(xpos))) { + delete trackTOFout; + continue; + } + + // 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; + } + } + + // 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); // Fill Tree for on-the-fly offline Calibration - if ( !((t->GetStatus() & AliESDtrack::kTIME)==0 )){ + if ( !((t->GetStatus() & AliESDtrack::kTIME)==0 ) ) { fIch=calindex; fToT=tToT; fTime=rawTime; @@ -628,6 +1087,8 @@ void AliTOFtracker::MatchTracks( Bool_t mLastStep){ } delete trackTOFout; } + + for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii]; delete [] clind; @@ -661,10 +1122,14 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) { AliInfo(Form("Number of clusters: %d",nc)); + fN = 0; + fNTOFmatched = 0; + for (Int_t i=0; iUncheckedAt(i); - fClusters[i]=new AliTOFcluster(*c); fN++; - +//PH fClusters[i]=new AliTOFcluster(*c); fN++; + fClusters[i]=c; fN++; + c->SetESDID(-1); // Fill Digits QA histos Int_t isector = c->GetDetInd(0); @@ -675,7 +1140,17 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) { 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: @@ -703,9 +1178,19 @@ Int_t AliTOFtracker::LoadClusters(TTree *cTree) { 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; } //_________________________________________________________________________ @@ -714,10 +1199,23 @@ void AliTOFtracker::UnloadClusters() { //This function unloads TOF clusters //-------------------------------------------------------------------- for (Int_t i=0; icd(); } //_________________________________________________________________________ -Float_t AliTOFtracker::CorrectTimeWalk( Float_t dist, Float_t tof) { +Float_t AliTOFtracker::CorrectTimeWalk( Float_t dist, Float_t tof) const { //dummy, for the moment Float_t tofcorr=0.; @@ -907,22 +1405,6 @@ Float_t AliTOFtracker::CorrectTimeWalk( Float_t dist, Float_t tof) { return tofcorr; } //_________________________________________________________________________ -Float_t AliTOFtracker::GetTimeZerofromT0(AliESDEvent *event) const { - - //Returns TimeZero as measured by T0 detector - - return event->GetT0(); -} -//_________________________________________________________________________ -Float_t AliTOFtracker::GetTimeZerofromTOF(AliESDEvent * /*event*/) const { - - //dummy, for the moment. T0 algorithm using tracks on TOF - { - //place T0 algo here... - } - return 0.; -} -//_________________________________________________________________________ void AliTOFtracker::FillClusterArray(TObjArray* arr) const { @@ -936,3 +1418,43 @@ void AliTOFtracker::FillClusterArray(TObjArray* arr) const for (Int_t i=0; iAdd(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; + // +}