#include "AliAlignObj.h"
#include "AliESDtrack.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliTrackPointArray.h"
#include "AliTOFcalib.h"
#include "AliTOFRecoParam.h"
#include "AliTOFcluster.h"
-#include "AliTOFGeometryV5.h"
+#include "AliTOFGeometry.h"
#include "AliTOFtracker.h"
#include "AliTOFtrack.h"
+#include "AliCDBManager.h"
extern TGeoManager *gGeoManager;
extern TROOT *gROOT;
{
//AliTOFtracker main Ctor
- fRecoParam=new AliTOFRecoParam();
+ // Gettimg the geometry
+ fGeom= new AliTOFGeometry();
+ // Read the reconstruction parameters from the OCDB
+ AliTOFcalib* calib=new AliTOFcalib();
+ fRecoParam = (AliTOFRecoParam*)calib->ReadRecParFromCDB("TOF/Calib",-1);
if(fRecoParam->GetApplyPbPbCuts())fRecoParam=fRecoParam->GetPbPbparam();
- fGeom=new AliTOFGeometryV5();
Double_t parPID[2];
parPID[0]=fRecoParam->GetTimeResolution();
parPID[1]=fRecoParam->GetTimeNSigma();
- AliDebug(2,Form("TOF PiD pars: %f %f",parPID[0],parPID[1]));
fPid=new AliTOFpidESD(parPID);
InitCheckHists();
-
+ delete calib;
}
//_____________________________________________________________________________
AliTOFtracker::AliTOFtracker(const AliTOFtracker &t):
fnunmatch=t.fnunmatch;
fnmatch=t.fnmatch;
fRecoParam=t.fRecoParam;
- fGeom=t.fGeom;
fPid=t.fPid;
fSeeds=t.fSeeds;
fTracks=t.fTracks;
this->fnunmatch=t.fnunmatch;
this->fnmatch=t.fnmatch;
this->fRecoParam = t.fRecoParam;
- this->fGeom = t.fGeom;
+ this->fGeom=t.fGeom;
this->fPid = t.fPid;
this->fSeeds=t.fSeeds;
this->fTracks=t.fTracks;
SaveCheckHists();
- delete fRecoParam;
+ if(!(AliCDBManager::Instance()->GetCacheFlag())){
+ delete fRecoParam;
+ }
delete fGeom;
delete fPid;
delete fHDigClusMap;
delete fCalTree;
}
//_____________________________________________________________________________
-Int_t AliTOFtracker::PropagateBack(AliESD* event) {
+Int_t AliTOFtracker::PropagateBack(AliESDEvent* event) {
//
// Gets seeds from ESD event and Match with TOF Clusters
//
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);
}
//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();
- 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
-
if (((t->GetStatus()&AliESDtrack::kTRDout)!=0 ) &&
- ( x >= fGeom->RinTOF()) ){
+ ( x >= AliTOFGeometry::RinTOF()) ){
track->SetSeedIndex(i);
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 dY=AliTOFGeometry::XPad();
+ Float_t dZ=AliTOFGeometry::ZPad();
Float_t sensRadius = fRecoParam->GetSensRadius();
Float_t stepSize = fRecoParam->GetStepSize();
Float_t dyMax=fRecoParam->GetWindowSizeMaxY();
Float_t dzMax=fRecoParam->GetWindowSizeMaxZ();
Float_t dCut=fRecoParam->GetDistanceCut();
- Double_t maxChi2=fRecoParam->GetMaxChi2();
-
+ Double_t maxChi2=fRecoParam->GetMaxChi2TRD();
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));
-
+ 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 nSteps=(Int_t)(detDepth/stepSize);
- AliTOFcalib *calib = new AliTOFcalib(fGeom);
-
//PH Arrays (moved outside of the loop)
Float_t * trackPos[4];
Int_t nStepsDone = 0;
for( Int_t istep=0; istep<nSteps; istep++){
- Float_t xs=fGeom->RinTOF()+istep*0.1;
- Double_t ymax=xs*TMath::Tan(0.5*fGeom->GetAlpha());
+ Float_t xs=AliTOFGeometry::RinTOF()+istep*0.1;
+ Double_t ymax=xs*TMath::Tan(0.5*AliTOFGeometry::GetAlpha());
Bool_t skip=kFALSE;
Double_t ysect=trackTOFin->GetYat(xs,skip);
if (skip) break;
if (ysect > ymax) {
- if (!trackTOFin->Rotate(fGeom->GetAlpha())) {
+ if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
break;
}
} else if (ysect <-ymax) {
- if (!trackTOFin->Rotate(fGeom->GetAlpha())) {
+ if (!trackTOFin->Rotate(AliTOFGeometry::GetAlpha())) {
break;
}
}
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
+ cxpos[nfound]=AliTOFGeometry::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=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));
Int_t ind[5];
ind[0]=c->GetDetInd(0);
ind[1]=c->GetDetInd(1);
ind[2]=c->GetDetInd(2);
ind[3]=c->GetDetInd(3);
ind[4]=c->GetDetInd(4);
- Int_t calindex = calib->GetIndex(ind);
+ Int_t calindex = AliTOFGeometry::GetIndex(ind);
t->SetTOFCalChannel(calindex);
// keep track of the track labels in the matched cluster
tlab[0]=c->GetLabel(0);
tlab[1]=c->GetLabel(1);
tlab[2]=c->GetLabel(2);
-
- Double_t tof=fGeom->TdcBinWidth()*c->GetTDC()+32; // in ps
- AliDebug(2,Form("tof before correction : %f",tof));
- if(timeWalkCorr)tof=CorrectTimeWalk(mindistZ,tof);
- AliDebug(2,Form("tof after correction : %f",tof));
- t->SetTOFsignal(tof);
+ 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));
+ 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];
}
for (Int_t ii=0; ii<4; ii++) delete [] trackPos[ii];
for (Int_t ii=0;ii<6;ii++) delete [] clind[ii];
- delete calib;
+
}
//_________________________________________________________________________
Int_t AliTOFtracker::LoadClusters(TTree *cTree) {
//This function loads the TOF clusters
//--------------------------------------------------------------------
- Int_t npadX = fGeom->NpadX();
- Int_t npadZ = fGeom->NpadZ();
- Int_t nStripA = fGeom->NStripA();
- Int_t nStripB = fGeom->NStripB();
- Int_t nStripC = fGeom->NStripC();
+ Int_t npadX = AliTOFGeometry::NpadX();
+ Int_t npadZ = AliTOFGeometry::NpadZ();
+ Int_t nStripA = AliTOFGeometry::NStripA();
+ Int_t nStripB = AliTOFGeometry::NStripB();
+ Int_t nStripC = AliTOFGeometry::NStripC();
TBranch *branch=cTree->GetBranch("TOF");
if (!branch) {
Int_t ipadX = c->GetDetInd(4);
Int_t ipadZ = c->GetDetInd(3);
- Float_t time =(fGeom->TdcBinWidth()*c->GetTDC())*1E-3; // in ns
- Float_t tot = (fGeom->TdcBinWidth()*c->GetToT())*1E-3;//in ns
+ Float_t time =(AliTOFGeometry::TdcBinWidth()*c->GetTDC())*1E-3; // in ns
+ Float_t tot = (AliTOFGeometry::TdcBinWidth()*c->GetToT())*1E-3;//in ns
Int_t stripOffset = 0;
switch (iplate) {
xyz[2] = cl->GetZ();
Float_t phiangle = (Int_t(cl->GetPhi()*TMath::RadToDeg()/20.)+0.5)*20.*TMath::DegToRad();
Float_t sinphi = TMath::Sin(phiangle), cosphi = TMath::Cos(phiangle);
- Float_t tiltangle = fGeom->GetAngles(cl->GetDetInd(1),cl->GetDetInd(2))*TMath::DegToRad();
+ Float_t tiltangle = AliTOFGeometry::GetAngles(cl->GetDetInd(1),cl->GetDetInd(2))*TMath::DegToRad();
Float_t sinth = TMath::Sin(tiltangle), costh = TMath::Cos(tiltangle);
- Float_t sigmay2 = fGeom->XPad()*fGeom->XPad()/12.;
- Float_t sigmaz2 = fGeom->ZPad()*fGeom->ZPad()/12.;
+ Float_t sigmay2 = AliTOFGeometry::XPad()*AliTOFGeometry::XPad()/12.;
+ Float_t sigmaz2 = AliTOFGeometry::ZPad()*AliTOFGeometry::ZPad()/12.;
Float_t cov[6];
cov[0] = sinphi*sinphi*sigmay2 + cosphi*cosphi*sinth*sinth*sigmaz2;
cov[1] = -sinphi*cosphi*sigmay2 + sinphi*cosphi*sinth*sinth*sigmaz2;
p.SetXYZ(xyz[0],xyz[1],xyz[2],cov);
// Detector numbering scheme
- Int_t nSector = fGeom->NSectors();
- Int_t nPlate = fGeom->NPlates();
- Int_t nStripA = fGeom->NStripA();
- Int_t nStripB = fGeom->NStripB();
- Int_t nStripC = fGeom->NStripC();
+ Int_t nSector = AliTOFGeometry::NSectors();
+ Int_t nPlate = AliTOFGeometry::NPlates();
+ Int_t nStripA = AliTOFGeometry::NStripA();
+ Int_t nStripB = AliTOFGeometry::NStripB();
+ Int_t nStripC = AliTOFGeometry::NStripC();
Int_t isector = cl->GetDetInd(0);
if (isector >= nSector)
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");
//dummy, for the moment
Float_t tofcorr=0.;
- if(dist<fGeom->ZPad()*0.5){
+ if(dist<AliTOFGeometry::ZPad()*0.5){
tofcorr=tof;
//place here the actual correction
}else{
return tofcorr;
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromT0(AliESD *event) {
+Float_t AliTOFtracker::GetTimeZerofromT0(AliESDEvent *event) const {
//Returns TimeZero as measured by T0 detector
return event->GetT0();
}
//_________________________________________________________________________
-Float_t AliTOFtracker::GetTimeZerofromTOF(AliESD *event) {
+Float_t AliTOFtracker::GetTimeZerofromTOF(AliESDEvent * /*event*/) const {
//dummy, for the moment. T0 algorithm using tracks on TOF
{
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff