{
//AliTOFtracker main Ctor
-
-
-
// Gettimg the geometry
fGeom=new AliTOFGeometryV5();
// Read the reconstruction parameters from the OCDB
AliTOFcalib *calib = new AliTOFcalib(fGeom);
fRecoParam = (AliTOFRecoParam*)calib->ReadRecParFromCDB("TOF/Calib",-1);
- if(!fRecoParam) {AliFatal("Exiting, no Reconstruction Parameters object found!!!");exit(0);}
if(fRecoParam->GetApplyPbPbCuts())fRecoParam=fRecoParam->GetPbPbparam();
Double_t parPID[2];
parPID[0]=fRecoParam->GetTimeResolution();
parPID[1]=fRecoParam->GetTimeNSigma();
- AliDebug(2,Form("TOF PID pars: Sigma= %f Range= %f",parPID[0],parPID[1]));
fPid=new AliTOFpidESD(parPID);
InitCheckHists();
AliESDtrack *t=event->GetTrack(i);
AliESDtrack *seed =(AliESDtrack*)fSeeds->UncheckedAt(i);
if(seed->GetTOFsignal()>0){
+ Float_t info[10];
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);
Bool_t timeZeroFromT0 = fRecoParam->GetTimeZerofromT0();
Bool_t timeZeroFromTOF = fRecoParam->GetTimeZerofromTOF();
- AliDebug(2,Form("Use Time Zero?: %d",usetimeZero));
- AliDebug(2,Form("Time Zero from T0? : %d",timeZeroFromT0));
- AliDebug(2,Form("Time Zero From TOF? : %d",timeZeroFromTOF));
+ 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));
if(usetimeZero){
if(timeZeroFromT0){
//_________________________________________________________________________
void AliTOFtracker::CollectESD() {
//prepare the set of ESD tracks to be matched to clusters in TOF
+
+ Int_t seedsTOF1=0;
+ Int_t seedsTOF2=0;
fTracks= new TClonesArray("AliTOFtrack");
TClonesArray &aTOFTrack = *fTracks;
AliESDtrack *t =(AliESDtrack*)fSeeds->UncheckedAt(i);
if ((t->GetStatus()&AliESDtrack::kTPCout)==0)continue;
- // TRD good tracks, already propagated at 371 cm
+ // TRD 'good' tracks, already propagated at 371 cm
AliTOFtrack *track = new AliTOFtrack(*t); // New
Double_t x = track->GetX(); //New
t->UpdateTrackParams(track,AliESDtrack::kTOFout);
new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
fNseedsTOF++;
+ seedsTOF1++;
delete track;
}
t->UpdateTrackParams(track,AliESDtrack::kTOFout);
new(aTOFTrack[fNseedsTOF]) AliTOFtrack(*track);
fNseedsTOF++;
+ seedsTOF2++;
}
delete track;
}
}
- AliInfo(Form("Number of TOF seedds %i",fNseedsTOF));
+ 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));
// Sort according uncertainties on track position
fTracks->Sort();
static Float_t corrLen=0.75;
static Float_t detDepth=15.3;
+ static Float_t padDepth=0.5;
Float_t dY=fGeom->XPad();
Float_t dZ=fGeom->ZPad();
Float_t dzMax=fRecoParam->GetWindowSizeMaxZ();
Float_t dCut=fRecoParam->GetDistanceCut();
Double_t maxChi2=fRecoParam->GetMaxChi2();
-
Bool_t timeWalkCorr = fRecoParam->GetTimeWalkCorr();
-
- AliDebug(2,Form("Time Walk Correction? : %d",timeWalkCorr));
-
- AliDebug(2,"TOF RecPars pars: \n");
- AliDebug(2,Form("TOF sens radius: %f",sensRadius));
- AliDebug(2,Form("TOF step size: %f",stepSize));
- AliDebug(2,Form("TOF Window scale factor: %f",scaleFact));
- AliDebug(2,Form("TOF Window max dy: %f",dyMax));
- AliDebug(2,Form("TOF Window max dz: %f",dzMax));
- AliDebug(2,Form("TOF distance Cut: %f",dCut));
- AliDebug(2,Form("TOF Max Chi2: %f",maxChi2));
-
+ if(!mLastStep){
+ AliDebug(1,"++++++++++++++TOF Reconstruction Parameters:++++++++++++ \n");
+ 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));
+ AliDebug(1,Form("TOF Window max dy: %f",dyMax));
+ AliDebug(1,Form("TOF Window max dz: %f",dzMax));
+ AliDebug(1,Form("TOF distance Cut: %f",dCut));
+ AliDebug(1,Form("TOF Max Chi2: %f",maxChi2));
+ AliDebug(1,Form("Time Walk Correction? : %d",timeWalkCorr));
+ }
//Match ESD tracks to clusters in TOF
Int_t nfound = 0;
+ Bool_t accept = kFALSE;
+ Bool_t isInside =kFALSE;
for (Int_t istep=0; istep<nStepsDone; istep++) {
- Bool_t isInside =kFALSE;
Float_t ctrackPos[3];
ctrackPos[0]= trackPos[0][istep];
//now see whether the track matches any of the TOF clusters
+ Float_t dist3d[3];
+ accept=kFALSE;
for (Int_t i=0; i<nc; i++){
Int_t cind[5];
cind[0]= clind[0][i];
cind[2]= clind[2][i];
cind[3]= clind[3][i];
cind[4]= clind[4][i];
- Bool_t accept = kFALSE;
- if( mLastStep)accept = (fGeom->DistanceToPad(cind,global[i],ctrackPos)<dCut);
- if(!mLastStep)accept = (fGeom->IsInsideThePad(cind,global[i],ctrackPos));
+ isInside=fGeom->IsInsideThePad(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)<padDepth*0.5 && rLoc<dCut);
+ }
+ else{
+ accept = isInside;
+ }
if(accept){
- if(!mLastStep)isInside=kTRUE;
- Float_t dist3d[3];
- dist[nfound]=fGeom->DistanceToPad(cind,global[i],ctrackPos,dist3d);
+ dist[nfound]=TMath::Sqrt(dist3d[0]*dist3d[0]+dist3d[1]*dist3d[1]+dist3d[2]*dist3d[2]);
distZ[nfound]=dist3d[2];
crecL[nfound]=trackPos[3][istep];
index[nfound]=clind[5][i]; // store cluster id
cxpos[nfound]=fGeom->RinTOF()+istep*0.1; //store prop.radius
nfound++;
- if(isInside)break;
+ if(accept &&!mLastStep)break;
}//end if accept
} //end for on the clusters
-
-
- if(isInside)break;
+ if(accept &&!mLastStep)break;
} //end for on the steps
}
}
+
AliTOFcluster *c=fClusters[idclus];
c->Use();
delete trackTOFin;
// Store quantities to be used in the TOF Calibration
- Float_t tToT=fGeom->TdcBinWidth()*c->GetToT()*1E-3; // in ns
+ Float_t tToT=fGeom->ToTBinWidth()*c->GetToT()*1E-3; // in ns
t->SetTOFsignalToT(tToT);
+ Float_t rawTime=fGeom->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));
Int_t ind[5];
ind[0]=c->GetDetInd(0);
ind[1]=c->GetDetInd(1);
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=fGeom->TdcBinWidth()*c->GetTDC()+32; // in ps
- if(timeWalkCorr)tof=CorrectTimeWalk(mindistZ,tof);
- t->SetTOFsignal(tof);
+ AliDebug(2,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));
+ //Set TOF time signal and pointer to the matched cluster
+ t->SetTOFsignal(tofcorr);
t->SetTOFcluster(idclus); // pointing to the recPoints tree
- Double_t time[10]; t->GetIntegratedTimes(time);
+
+ //Tracking info
+ Double_t time[AliPID::kSPECIES]; t->GetIntegratedTimes(time);
Double_t mom=t->GetP();
- for(Int_t j=0;j<=AliPID::kSPECIES;j++){
+ for(Int_t j=0;j<AliPID::kSPECIES;j++){
Double_t mass=AliPID::ParticleMass(j);
time[j]+=(recL-trackPos[3][0])/3e-2*TMath::Sqrt(mom*mom+mass*mass)/mom;
}
t->SetIntegratedLength(recL);
t->SetIntegratedTimes(time);
t->SetTOFLabel(tlab);
+
+
// Fill Reco-QA histos for Reconstruction
fHRecNClus->Fill(nc);
fHRecDist->Fill(mindist);
// Fill Tree for on-the-fly offline Calibration
if ( !((t->GetStatus() & AliESDtrack::kTIME)==0 )){
- Float_t rawtime=fGeom->TdcBinWidth()*c->GetTDCRAW()+32; // RAW time,in ps
fIch=calindex;
fToT=tToT;
- fTime=rawtime;
+ fTime=rawTime;
fExpTimePi=time[2];
fExpTimeKa=time[3];
fExpTimePr=time[4];
Int_t idet = (2*(nStripC+nStripB)+nStripA)*isector +
stripOffset +
istrip;
- UShort_t volid = AliAlignObj::LayerToVolUID(AliAlignObj::kTOF,idet);
+ UShort_t volid = AliGeomManager::LayerToVolUID(AliGeomManager::kTOF,idet);
p.SetVolumeID((UShort_t)volid);
return kTRUE;
}
fHRecSigZVsP->Write(fHRecSigZVsP->GetName(), TObject::kOverwrite);
fHRecSigYVsPWin->Write(fHRecSigYVsPWin->GetName(), TObject::kOverwrite);
fHRecSigZVsPWin->Write(fHRecSigZVsPWin->GetName(), TObject::kOverwrite);
- fCalTree->Write(fCalTree->GetName(),TObject::kOverwrite);
+ //fCalTree->Write(fCalTree->GetName(),TObject::kOverwrite);
logFile->Flush();
if(!isThere)logFileTOF = new TFile( "TOFQA.root","RECREATE");
return tofcorr;
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromT0(AliESD *event) {
+Float_t AliTOFtracker::GetTimeZerofromT0(AliESD *event) const {
//Returns TimeZero as measured by T0 detector
return event->GetT0();
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromTOF(AliESD *event) {
+Float_t AliTOFtracker::GetTimeZerofromTOF(AliESD * /*event*/) const {
//dummy, for the moment. T0 algorithm using tracks on TOF
{
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff