X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCtrackerMI.cxx;h=6edb2eb50e2060d93a34f5c196444b6586231d2d;hb=4ce766eb4226c070c454ba72807fbf481119a5cb;hp=94778b20e2e31c5a5fd6a9125e61185ddd6ec630;hpb=167c41abf0d9705aecf1a9248d4144510ba722d2;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCtrackerMI.cxx b/TPC/AliTPCtrackerMI.cxx index 94778b20e2e..6edb2eb50e2 100644 --- a/TPC/AliTPCtrackerMI.cxx +++ b/TPC/AliTPCtrackerMI.cxx @@ -19,12 +19,90 @@ // // Origin: Marian Ivanov Marian.Ivanov@cern.ch // -// AliTPC parallel tracker - -// How to use? - -// run AliTPCFindClusters.C macro - clusters neccessary for tracker are founded -// run AliTPCFindTracksMI.C macro - to find tracks -// tracks are written to AliTPCtracks.root file -// for comparison also seeds are written to the same file - to special branch +// AliTPC parallel tracker +// +// The track fitting is based on Kalaman filtering approach + +// The track finding steps: +// 1. Seeding - with and without vertex constraint +// - seeding with vertex constain done at first n^2 proble +// - seeding without vertex constraint n^3 problem +// 2. Tracking - follow prolongation road - find cluster - update kalman track + +// The seeding and tracking is repeated several times, in different seeding region. +// This approach enables to find the track which cannot be seeded in some region of TPC +// This can happen because of low momenta (track do not reach outer radius), or track is currently in the ded region between sectors, or the track is for the moment overlapped with other track (seed quality is poor) ... + +// With this approach we reach almost 100 % efficiency also for high occupancy events. +// (If the seeding efficiency in a region is about 90 % than with logical or of several +// regions we will reach 100% (in theory - supposing independence) + +// Repeating several seeding - tracking procedures some of the tracks can be find +// several times. + +// The procedures to remove multi find tacks are impremented: +// RemoveUsed2 - fast procedure n problem - +// Algorithm - Sorting tracks according quality +// remove tracks with some shared fraction +// Sharing in respect to all tacks +// Signing clusters in gold region +// FindSplitted - slower algorithm n^2 +// Sort the tracks according quality +// Loop over pair of tracks +// If overlap with other track bigger than threshold - remove track +// +// FindCurling - Finds the pair of tracks which are curling +// - About 10% of tracks can be find with this procedure +// The combinatorial background is too big to be used in High +// multiplicity environment +// - n^2 problem - Slow procedure - currently it is disabled because of +// low efficiency +// +// The number of splitted tracks can be reduced disabling the sharing of the cluster. +// tpcRecoParam-> SetClusterSharing(kFALSE); +// IT IS HIGHLY non recomended to use it in high flux enviroonment +// Even using this switch some tracks can be found more than once +// (because of multiple seeding and low quality tracks which will not cross full chamber) +// +// +// The tracker itself can be debugged - the information about tracks can be stored in several // phases of the reconstruction +// To enable storage of the TPC tracks in the ESD friend track +// use AliTPCReconstructor::SetStreamLevel(n); +// +// The debug level - different procedure produce tree for numerical debugging +// To enable them set AliTPCReconstructor::SetStreamLevel(n); where nis bigger 1 +// + +// +// Adding systematic errors to the covariance: +// +// The systematic errors due to the misalignment and miscalibration are added to the covariance matrix +// of the tracks (not to the clusters as they are dependent): +// The parameters form AliTPCRecoParam are used AliTPCRecoParam::GetSystematicError +// The systematic errors are expressed there in RMS - position (cm), angle (rad), curvature (1/cm) +// The default values are 0. +// +// The sytematic errors are added to the covariance matrix in following places: +// +// 1. During fisrt itteration - AliTPCtrackerMI::FillESD +// 2. Second iteration - +// 2.a ITS->TPC - AliTPCtrackerMI::ReadSeeds +// 2.b TPC->TRD - AliTPCtrackerMI::PropagateBack +// 3. Third iteration - +// 3.a TRD->TPC - AliTPCtrackerMI::ReadSeeds +// 3.b TPC->ITS - AliTPCtrackerMI::RefitInward +// +// There are several places in the code which can be numerically debuged +// This code is keeped in order to enable code development and to check the calibration implementtion +// +// 1. ErrParam stream - dump information about +// 1.a) cluster +// 2.a) cluster error estimate +// 3.a) cluster shape estimate +// +// +// Debug streamer levels: +// //------------------------------------------------------- @@ -35,33 +113,39 @@ #include #include #include - +#include "AliLog.h" #include "AliComplexCluster.h" -#include "AliESD.h" -#include "AliESDkink.h" +#include "AliESDEvent.h" +#include "AliESDtrack.h" +#include "AliESDVertex.h" +#include "AliKink.h" +#include "AliV0.h" #include "AliHelix.h" #include "AliRunLoader.h" #include "AliTPCClustersRow.h" #include "AliTPCParam.h" #include "AliTPCReconstructor.h" -#include "AliTPCclusterMI.h" #include "AliTPCpolyTrack.h" #include "AliTPCreco.h" -#include "AliTPCseed.h" +#include "AliTPCseed.h" + +#include "AliTPCtrackerSector.h" #include "AliTPCtrackerMI.h" #include "TStopwatch.h" #include "AliTPCReconstructor.h" -#include "AliESDkink.h" -#include "AliPID.h" -#include "TTreeStream.h" #include "AliAlignObj.h" #include "AliTrackPointArray.h" +#include "TRandom.h" +#include "AliTPCcalibDB.h" +#include "AliTPCTransform.h" +#include "AliTPCClusterParam.h" // ClassImp(AliTPCtrackerMI) + class AliTPCFastMath { public: AliTPCFastMath(); @@ -93,7 +177,33 @@ Double_t AliTPCFastMath::FastAsin(Double_t x){ Int_t index = int(x*10000); return -(fgFastAsin[2*index]+(x*10000.-index)*fgFastAsin[2*index+1]); } - +//__________________________________________________________________ +AliTPCtrackerMI::AliTPCtrackerMI() + :AliTracker(), + fkNIS(0), + fInnerSec(0), + fkNOS(0), + fOuterSec(0), + fN(0), + fSectors(0), + fInput(0), + fOutput(0), + fSeedTree(0), + fTreeDebug(0), + fEvent(0), + fDebug(0), + fNewIO(kFALSE), + fNtracks(0), + fSeeds(0), + fIteration(0), + fkParam(0), + fDebugStreamer(0) +{ + // + // default constructor + // +} +//_____________________________________________________________________ @@ -102,63 +212,63 @@ Int_t AliTPCtrackerMI::UpdateTrack(AliTPCseed * track, Int_t accept){ //update track information using current cluster - track->fCurrentCluster - AliTPCclusterMI* c =track->fCurrentCluster; - if (accept>0) track->fCurrentClusterIndex1 |=0x8000; //sign not accepted clusters + AliTPCclusterMI* c =track->GetCurrentCluster(); + if (accept>0) track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000); //sign not accepted clusters - UInt_t i = track->fCurrentClusterIndex1; + UInt_t i = track->GetCurrentClusterIndex1(); Int_t sec=(i&0xff000000)>>24; //Int_t row = (i&0x00ff0000)>>16; - track->fRow=(i&0x00ff0000)>>16; - track->fSector = sec; + track->SetRow((i&0x00ff0000)>>16); + track->SetSector(sec); // Int_t index = i&0xFFFF; - if (sec>=fParam->GetNInnerSector()) track->fRow += fParam->GetNRowLow(); - track->SetClusterIndex2(track->fRow, i); + if (sec>=fkParam->GetNInnerSector()) track->SetRow(track->GetRow()+fkParam->GetNRowLow()); + track->SetClusterIndex2(track->GetRow(), i); //track->fFirstPoint = row; //if ( track->fLastPointfLastPoint =row; // if (track->fRow<0 || track->fRow>160) { // printf("problem\n"); //} - if (track->fFirstPoint>track->fRow) - track->fFirstPoint = track->fRow; - if (track->fLastPointfRow) - track->fLastPoint = track->fRow; + if (track->GetFirstPoint()>track->GetRow()) + track->SetFirstPoint(track->GetRow()); + if (track->GetLastPoint()GetRow()) + track->SetLastPoint(track->GetRow()); - track->fClusterPointer[track->fRow] = c; + track->SetClusterPointer(track->GetRow(),c); // - Float_t angle2 = track->GetSnp()*track->GetSnp(); - angle2 = TMath::Sqrt(angle2/(1-angle2)); + Double_t angle2 = track->GetSnp()*track->GetSnp(); // //SET NEW Track Point // - // if (debug) + if (angle2<1) //PH sometimes angle2 is very big. To be investigated... { - AliTPCTrackerPoint &point =*(track->GetTrackPoint(track->fRow)); + angle2 = TMath::Sqrt(angle2/(1-angle2)); + AliTPCTrackerPoint &point =*(track->GetTrackPoint(track->GetRow())); // - point.SetSigmaY(c->GetSigmaY2()/track->fCurrentSigmaY2); - point.SetSigmaZ(c->GetSigmaZ2()/track->fCurrentSigmaZ2); - point.SetErrY(sqrt(track->fErrorY2)); - point.SetErrZ(sqrt(track->fErrorZ2)); + point.SetSigmaY(c->GetSigmaY2()/track->GetCurrentSigmaY2()); + point.SetSigmaZ(c->GetSigmaZ2()/track->GetCurrentSigmaZ2()); + point.SetErrY(sqrt(track->GetErrorY2())); + point.SetErrZ(sqrt(track->GetErrorZ2())); // point.SetX(track->GetX()); point.SetY(track->GetY()); point.SetZ(track->GetZ()); point.SetAngleY(angle2); point.SetAngleZ(track->GetTgl()); - if (point.fIsShared){ - track->fErrorY2 *= 4; - track->fErrorZ2 *= 4; + if (point.IsShared()){ + track->SetErrorY2(track->GetErrorY2()*4); + track->SetErrorZ2(track->GetErrorZ2()*4); } } - Double_t chi2 = track->GetPredictedChi2(track->fCurrentCluster); + Double_t chi2 = track->GetPredictedChi2(track->GetCurrentCluster()); // - track->fErrorY2 *= 1.3; - track->fErrorY2 += 0.01; - track->fErrorZ2 *= 1.3; - track->fErrorZ2 += 0.005; +// track->SetErrorY2(track->GetErrorY2()*1.3); +// track->SetErrorY2(track->GetErrorY2()+0.01); +// track->SetErrorZ2(track->GetErrorZ2()*1.3); +// track->SetErrorZ2(track->GetErrorZ2()+0.005); //} if (accept>0) return 0; if (track->GetNumberOfClusters()%20==0){ @@ -168,47 +278,88 @@ Int_t AliTPCtrackerMI::UpdateTrack(AliTPCseed * track, Int_t accept){ // new(larr[ihelix]) AliHelix(*track) ; //} } - track->fNoCluster =0; + track->SetNoCluster(0); return track->Update(c,chi2,i); } -Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluster, Float_t factor, - Float_t cory, Float_t corz) +Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluster) { // // decide according desired precision to accept given // cluster for tracking - Double_t sy2=ErrY2(seed,cluster)*cory; - Double_t sz2=ErrZ2(seed,cluster)*corz; - //sy2=ErrY2(seed,cluster)*cory; - //sz2=ErrZ2(seed,cluster)*cory; + Double_t yt=0,zt=0; + seed->GetProlongation(cluster->GetX(),yt,zt); + Double_t sy2=ErrY2(seed,cluster); + Double_t sz2=ErrZ2(seed,cluster); Double_t sdistancey2 = sy2+seed->GetSigmaY2(); Double_t sdistancez2 = sz2+seed->GetSigmaZ2(); - - Double_t rdistancey2 = (seed->fCurrentCluster->GetY()-seed->GetY())* - (seed->fCurrentCluster->GetY()-seed->GetY())/sdistancey2; - Double_t rdistancez2 = (seed->fCurrentCluster->GetZ()-seed->GetZ())* - (seed->fCurrentCluster->GetZ()-seed->GetZ())/sdistancez2; + Double_t dy=seed->GetCurrentCluster()->GetY()-yt; + Double_t dz=seed->GetCurrentCluster()->GetZ()-zt; + Double_t rdistancey2 = (seed->GetCurrentCluster()->GetY()-yt)* + (seed->GetCurrentCluster()->GetY()-yt)/sdistancey2; + Double_t rdistancez2 = (seed->GetCurrentCluster()->GetZ()-zt)* + (seed->GetCurrentCluster()->GetZ()-zt)/sdistancez2; Double_t rdistance2 = rdistancey2+rdistancez2; //Int_t accept =0; - if (rdistance2>16) return 3; + if (AliTPCReconstructor::StreamLevel()>2 && seed->GetNumberOfClusters()>20) { + Float_t rmsy2 = seed->GetCurrentSigmaY2(); + Float_t rmsz2 = seed->GetCurrentSigmaZ2(); + Float_t rmsy2p30 = seed->GetCMeanSigmaY2p30(); + Float_t rmsz2p30 = seed->GetCMeanSigmaZ2p30(); + Float_t rmsy2p30R = seed->GetCMeanSigmaY2p30R(); + Float_t rmsz2p30R = seed->GetCMeanSigmaZ2p30R(); + AliExternalTrackParam param(*seed); + static TVectorD gcl(3),gtr(3); + Float_t gclf[3]; + param.GetXYZ(gcl.GetMatrixArray()); + cluster->GetGlobalXYZ(gclf); + gcl[0]=gclf[0]; gcl[1]=gclf[1]; gcl[2]=gclf[2]; + + + if (AliTPCReconstructor::StreamLevel()>2) { + (*fDebugStreamer)<<"ErrParam"<< + "Cl.="<32) return 3; - if ((rdistancey2>9.*factor || rdistancez2>9.*factor) && cluster->GetType()==0) + if ((rdistancey2>9. || rdistancez2>9.) && cluster->GetType()==0) return 2; //suspisiouce - will be changed - if ((rdistancey2>6.25*factor || rdistancez2>6.25*factor) && cluster->GetType()>0) + if ((rdistancey2>6.25 || rdistancez2>6.25) && cluster->GetType()>0) // strict cut on overlaped cluster return 2; //suspisiouce - will be changed - if ( (rdistancey2>1.*factor || rdistancez2>6.25*factor ) + if ( (rdistancey2>1. || rdistancez2>6.25 ) && cluster->GetType()<0){ - seed->fNFoundable--; + seed->SetNFoundable(seed->GetNFoundable()-1); return 2; } return 0; @@ -217,63 +368,90 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste + //_____________________________________________________________________________ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCParam *par): -AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2) +AliTracker(), + fkNIS(par->GetNInnerSector()/2), + fInnerSec(0), + fkNOS(par->GetNOuterSector()/2), + fOuterSec(0), + fN(0), + fSectors(0), + fInput(0), + fOutput(0), + fSeedTree(0), + fTreeDebug(0), + fEvent(0), + fDebug(0), + fNewIO(0), + fNtracks(0), + fSeeds(0), + fIteration(0), + fkParam(0), + fDebugStreamer(0) { //--------------------------------------------------------------------- // The main TPC tracker constructor //--------------------------------------------------------------------- - fInnerSec=new AliTPCSector[fkNIS]; - fOuterSec=new AliTPCSector[fkNOS]; + fInnerSec=new AliTPCtrackerSector[fkNIS]; + fOuterSec=new AliTPCtrackerSector[fkNOS]; Int_t i; for (i=0; iGetNRowLow(); Int_t nrowup = par->GetNRowUp(); - for (Int_t i=0;iGetPadRowRadiiLow(i); fPadLength[i]= par->GetPadPitchLength(0,i); fYMax[i] = fXRow[i]*TMath::Tan(0.5*par->GetInnerAngle()); } - for (Int_t i=0;iGetPadRowRadiiUp(i); fPadLength[i+nrowlow] = par->GetPadPitchLength(60,i); fYMax[i+nrowlow] = fXRow[i+nrowlow]*TMath::Tan(0.5*par->GetOuterAngle()); } - fSeeds=0; - // - fInput = 0; - fOutput = 0; - fSeedTree = 0; - fTreeDebug =0; - fNewIO =0; - fDebug =0; - fEvent =0; - fDebugStreamer = new TTreeSRedirector("TPCdebug.root"); + + if (AliTPCReconstructor::StreamLevel()>0) { + fDebugStreamer = new TTreeSRedirector("TPCdebug.root"); + } } //________________________________________________________________________ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t): AliTracker(t), - fkNIS(t.fkNIS), - fkNOS(t.fkNOS) + fkNIS(t.fkNIS), + fInnerSec(0), + fkNOS(t.fkNOS), + fOuterSec(0), + fN(0), + fSectors(0), + fInput(0), + fOutput(0), + fSeedTree(0), + fTreeDebug(0), + fEvent(0), + fDebug(0), + fNewIO(kFALSE), + fNtracks(0), + fSeeds(0), + fIteration(0), + fkParam(0), + fDebugStreamer(0) { //------------------------------------ // dummy copy constructor //------------------------------------------------------------------ + fOutput=t.fOutput; } -AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/){ +AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/) +{ //------------------------------ // dummy //-------------------------------------------------------------- @@ -293,70 +471,8 @@ AliTPCtrackerMI::~AliTPCtrackerMI() { if (fDebugStreamer) delete fDebugStreamer; } -void AliTPCtrackerMI::SetIO() -{ - // - fNewIO = kTRUE; - fInput = AliRunLoader::GetTreeR("TPC", kFALSE,AliConfig::GetDefaultEventFolderName()); - - fOutput = AliRunLoader::GetTreeT("TPC", kTRUE,AliConfig::GetDefaultEventFolderName()); - if (fOutput){ - AliTPCtrack *iotrack= new AliTPCtrack; - fOutput->Branch("tracks","AliTPCtrack",&iotrack,32000,100); - delete iotrack; - } -} - -void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESD * event) -{ - - // set input - fNewIO = kFALSE; - fInput = 0; - fOutput = 0; - fSeedTree = 0; - fTreeDebug =0; - fInput = input; - if (input==0){ - return; - } - //set output - fOutput = output; - if (output){ - AliTPCtrack *iotrack= new AliTPCtrack; - // iotrack->fHelixIn = new TClonesArray("AliHelix"); - //iotrack->fHelixOut = new TClonesArray("AliHelix"); - fOutput->Branch("tracks","AliTPCtrack",&iotrack,32000,100); - delete iotrack; - } - if (output && (fDebug&2)){ - //write the full seed information if specified in debug mode - // - fSeedTree = new TTree("Seeds","Seeds"); - AliTPCseed * vseed = new AliTPCseed; - // - TClonesArray * arrtr = new TClonesArray("AliTPCTrackPoint",160); - arrtr->ExpandCreateFast(160); - TClonesArray * arre = new TClonesArray("AliTPCExactPoint",160); - // - vseed->fPoints = arrtr; - vseed->fEPoints = arre; - // vseed->fClusterPoints = arrcl; - fSeedTree->Branch("seeds","AliTPCseed",&vseed,32000,99); - delete arrtr; - delete arre; - fTreeDebug = new TTree("trackDebug","trackDebug"); - TClonesArray * arrd = new TClonesArray("AliTPCTrackPoint2",0); - fTreeDebug->Branch("debug",&arrd,32000,99); - } - - - //set ESD event - fEvent = event; -} - -void AliTPCtrackerMI::FillESD(TObjArray* arr) +void AliTPCtrackerMI::FillESD(const TObjArray* arr) { // // @@ -370,9 +486,15 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); if (!pt) continue; pt->UpdatePoints(); - // pt->PropagateTo(fParam->GetInnerRadiusLow()); + AddCovariance(pt); + if (AliTPCReconstructor::StreamLevel()>1) { + (*fDebugStreamer)<<"Track0"<< + "Tr0.="<PropagateTo(fkParam->GetInnerRadiusLow()); if (pt->GetKinkIndex(0)<=0){ //don't propagate daughter tracks - pt->PropagateTo(fParam->GetInnerRadiusLow()); + pt->PropagateTo(fkParam->GetInnerRadiusLow()); } if (( pt->GetPoints()[2]- pt->GetPoints()[0])>5 && pt->GetPoints()[3]>0.8){ @@ -387,7 +509,7 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) continue; } - if ( (pt->GetNumberOfClusters()>70)&& (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.55) { + if ( (pt->GetNumberOfClusters()>70)&& (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.55) { AliESDtrack iotrack; iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin); iotrack.SetTPCPoints(pt->GetPoints()); @@ -401,10 +523,10 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) // // short tracks - maybe decays - if ( (pt->GetNumberOfClusters()>30) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.70) { + if ( (pt->GetNumberOfClusters()>30) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.70) { Int_t found,foundable,shared; pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE); - if ( (found>20) && (pt->fNShared/float(pt->GetNumberOfClusters())<0.2)){ + if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2)){ AliESDtrack iotrack; iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin); //iotrack.SetTPCindex(i); @@ -417,11 +539,11 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) } } - if ( (pt->GetNumberOfClusters()>20) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.8) { + if ( (pt->GetNumberOfClusters()>20) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.8) { Int_t found,foundable,shared; pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE); if (found<20) continue; - if (pt->fNShared/float(pt->GetNumberOfClusters())>0.2) continue; + if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue; // AliESDtrack iotrack; iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin); @@ -438,7 +560,7 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) if ( (pt->GetNumberOfClusters()>30) ) { Int_t found,foundable,shared; pt->GetClusterStatistic(128,158,found, foundable,shared,kFALSE); - if ( (found>20) && (pt->fNShared/float(pt->GetNumberOfClusters())<0.2) &&float(found)/float(foundable)>0.8){ + if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2) &&float(found)/float(foundable)>0.8){ AliESDtrack iotrack; iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin); iotrack.SetTPCPoints(pt->GetPoints()); @@ -455,7 +577,8 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) Int_t found,foundable,shared; pt->GetClusterStatistic(138,158,found, foundable,shared,kFALSE); if (found<15) continue; - if (pt->fNShared/float(pt->GetNumberOfClusters())>0.2) continue; + if (foundable<=0) continue; + if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue; if (float(found)/float(foundable)<0.8) continue; // AliESDtrack iotrack; @@ -469,449 +592,338 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) continue; } } + // >> account for suppressed tracks in the kink indices (RS) + int nESDtracks = fEvent->GetNumberOfTracks(); + for (int it=nESDtracks;it--;) { + AliESDtrack* esdTr = fEvent->GetTrack(it); + if (!esdTr || !esdTr->GetKinkIndex(0)) continue; + for (int ik=0;ik<3;ik++) { + int knkId=0; + if (!(knkId=esdTr->GetKinkIndex(ik))) break; // no more kinks for this track + AliESDkink* kink = fEvent->GetKink(TMath::Abs(knkId)-1); + if (!kink) { + AliError(Form("ESDTrack%d refers to non-existing kink %d",it,TMath::Abs(knkId)-1)); + continue; + } + kink->SetIndex(it, knkId<0 ? 0:1); // update track index of the kink: mother at 0, daughter at 1 + } + } + // << account for suppressed tracks in the kink indices (RS) } - printf("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks()); -} - -void AliTPCtrackerMI::WriteTracks(TTree * tree) -{ - // - // write tracks from seed array to selected tree - // - fOutput = tree; - if (fOutput){ - AliTPCtrack *iotrack= new AliTPCtrack; - fOutput->Branch("tracks","AliTPCtrack",&iotrack,32000,100); - } - WriteTracks(); + AliInfo(Form("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks())); } -void AliTPCtrackerMI::WriteTracks() -{ - // - // write tracks to the given output tree - - // output specified with SetIO routine - if (!fSeeds) return; - if (!fOutput){ - SetIO(); - } - - if (fOutput){ - AliTPCtrack *iotrack= 0; - Int_t nseed=fSeeds->GetEntriesFast(); - //for (Int_t i=0; iUncheckedAt(i); - // if (iotrack) break; - //} - //TBranch * br = fOutput->Branch("tracks","AliTPCtrack",&iotrack,32000,100); - TBranch * br = fOutput->GetBranch("tracks"); - br->SetAddress(&iotrack); - // - for (Int_t i=0; iUncheckedAt(i); - if (!pt) continue; - AliTPCtrack * track = new AliTPCtrack(*pt); - iotrack = track; - pt->fLab2 =i; - // br->SetAddress(&iotrack); - fOutput->Fill(); - delete track; - iotrack =0; - } - //fOutput->GetDirectory()->cd(); - //fOutput->Write(); - } - // delete iotrack; - // - if (fSeedTree){ - //write the full seed information if specified in debug mode - - AliTPCseed * vseed = new AliTPCseed; - // - TClonesArray * arrtr = new TClonesArray("AliTPCTrackPoint",160); - arrtr->ExpandCreateFast(160); - //TClonesArray * arrcl = new TClonesArray("AliTPCclusterMI",160); - //arrcl->ExpandCreateFast(160); - TClonesArray * arre = new TClonesArray("AliTPCExactPoint",160); - // - vseed->fPoints = arrtr; - vseed->fEPoints = arre; - // vseed->fClusterPoints = arrcl; - //TBranch * brseed = seedtree->Branch("seeds","AliTPCseed",&vseed,32000,99); - TBranch * brseed = fSeedTree->GetBranch("seeds"); - - Int_t nseed=fSeeds->GetEntriesFast(); - - for (Int_t i=0; iUncheckedAt(i); - if (!pt) continue; - pt->fPoints = arrtr; - // pt->fClusterPoints = arrcl; - pt->fEPoints = arre; - pt->RebuildSeed(); - vseed = pt; - brseed->SetAddress(&vseed); - fSeedTree->Fill(); - pt->fPoints = 0; - pt->fEPoints = 0; - // pt->fClusterPoints = 0; - } - fSeedTree->Write(); - if (fTreeDebug) fTreeDebug->Write(); - } -} - -Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ +Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){ // // - //seed->SetErrorY2(0.1); - //return 0.1; - //calculate look-up table at the beginning - static Bool_t ginit = kFALSE; - static Float_t gnoise1,gnoise2,gnoise3; - static Float_t ggg1[10000]; - static Float_t ggg2[10000]; - static Float_t ggg3[10000]; - static Float_t glandau1[10000]; - static Float_t glandau2[10000]; - static Float_t glandau3[10000]; + // Use calibrated cluster error from OCDB // - static Float_t gcor01[500]; - static Float_t gcor02[500]; - static Float_t gcorp[500]; + AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); // + Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())); + Int_t ctype = cl->GetType(); + Int_t type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2; + Double_t angle = seed->GetSnp()*seed->GetSnp(); + angle = TMath::Sqrt(TMath::Abs(angle/(1.-angle))); + Double_t erry2 = clparam->GetError0Par(0,type, z,angle); + if (ctype<0) { + erry2+=0.5; // edge cluster + } + erry2*=erry2; + seed->SetErrorY2(erry2); + // + return erry2; + +//calculate look-up table at the beginning +// static Bool_t ginit = kFALSE; +// static Float_t gnoise1,gnoise2,gnoise3; +// static Float_t ggg1[10000]; +// static Float_t ggg2[10000]; +// static Float_t ggg3[10000]; +// static Float_t glandau1[10000]; +// static Float_t glandau2[10000]; +// static Float_t glandau3[10000]; +// // +// static Float_t gcor01[500]; +// static Float_t gcor02[500]; +// static Float_t gcorp[500]; +// // - // - if (ginit==kFALSE){ - for (Int_t i=1;i<500;i++){ - Float_t rsigma = float(i)/100.; - gcor02[i] = TMath::Max(0.78 +TMath::Exp(7.4*(rsigma-1.2)),0.6); - gcor01[i] = TMath::Max(0.72 +TMath::Exp(3.36*(rsigma-1.2)),0.6); - gcorp[i] = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2); - } +// // +// if (ginit==kFALSE){ +// for (Int_t i=1;i<500;i++){ +// Float_t rsigma = float(i)/100.; +// gcor02[i] = TMath::Max(0.78 +TMath::Exp(7.4*(rsigma-1.2)),0.6); +// gcor01[i] = TMath::Max(0.72 +TMath::Exp(3.36*(rsigma-1.2)),0.6); +// gcorp[i] = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2); +// } - // - for (Int_t i=3;i<10000;i++){ - // - // - // inner sector - Float_t amp = float(i); - Float_t padlength =0.75; - gnoise1 = 0.0004/padlength; - Float_t nel = 0.268*amp; - Float_t nprim = 0.155*amp; - ggg1[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel; - glandau1[i] = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau1[i]>1) glandau1[i]=1; - glandau1[i]*=padlength*padlength/12.; - // - // outer short - padlength =1.; - gnoise2 = 0.0004/padlength; - nel = 0.3*amp; - nprim = 0.133*amp; - ggg2[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; - glandau2[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau2[i]>1) glandau2[i]=1; - glandau2[i]*=padlength*padlength/12.; - // - // - // outer long - padlength =1.5; - gnoise3 = 0.0004/padlength; - nel = 0.3*amp; - nprim = 0.133*amp; - ggg3[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; - glandau3[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau3[i]>1) glandau3[i]=1; - glandau3[i]*=padlength*padlength/12.; - // - } - ginit = kTRUE; - } - // - // - // - Int_t amp = int(TMath::Abs(cl->GetQ())); - if (amp>9999) { - seed->SetErrorY2(1.); - return 1.; - } - Float_t snoise2; - Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ())); - Int_t ctype = cl->GetType(); - Float_t padlength= GetPadPitchLength(seed->fRow); - Float_t angle2 = seed->GetSnp()*seed->GetSnp(); - angle2 = angle2/(1-angle2); - // - //cluster "quality" - Int_t rsigmay = int(100.*cl->GetSigmaY2()/(seed->fCurrentSigmaY2)); - Float_t res; - // - if (fSectors==fInnerSec){ - snoise2 = gnoise1; - res = ggg1[amp]*z+glandau1[amp]*angle2; - if (ctype==0) res *= gcor01[rsigmay]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmay]; - } - } - else { - if (padlength<1.1){ - snoise2 = gnoise2; - res = ggg2[amp]*z+glandau2[amp]*angle2; - if (ctype==0) res *= gcor02[rsigmay]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmay]; - } - } - else{ - snoise2 = gnoise3; - res = ggg3[amp]*z+glandau3[amp]*angle2; - if (ctype==0) res *= gcor02[rsigmay]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmay]; - } - } - } +// // +// for (Int_t i=3;i<10000;i++){ +// // +// // +// // inner sector +// Float_t amp = float(i); +// Float_t padlength =0.75; +// gnoise1 = 0.0004/padlength; +// Float_t nel = 0.268*amp; +// Float_t nprim = 0.155*amp; +// ggg1[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel; +// glandau1[i] = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau1[i]>1) glandau1[i]=1; +// glandau1[i]*=padlength*padlength/12.; +// // +// // outer short +// padlength =1.; +// gnoise2 = 0.0004/padlength; +// nel = 0.3*amp; +// nprim = 0.133*amp; +// ggg2[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; +// glandau2[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau2[i]>1) glandau2[i]=1; +// glandau2[i]*=padlength*padlength/12.; +// // +// // +// // outer long +// padlength =1.5; +// gnoise3 = 0.0004/padlength; +// nel = 0.3*amp; +// nprim = 0.133*amp; +// ggg3[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; +// glandau3[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau3[i]>1) glandau3[i]=1; +// glandau3[i]*=padlength*padlength/12.; +// // +// } +// ginit = kTRUE; +// } +// // +// // +// // +// Int_t amp = int(TMath::Abs(cl->GetQ())); +// if (amp>9999) { +// seed->SetErrorY2(1.); +// return 1.; +// } +// Float_t snoise2; +// Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())); +// Int_t ctype = cl->GetType(); +// Float_t padlength= GetPadPitchLength(seed->GetRow()); +// Double_t angle2 = seed->GetSnp()*seed->GetSnp(); +// angle2 = angle2/(1-angle2); +// // +// //cluster "quality" +// Int_t rsigmay = int(100.*cl->GetSigmaY2()/(seed->GetCurrentSigmaY2())); +// Float_t res; +// // +// if (fSectors==fInnerSec){ +// snoise2 = gnoise1; +// res = ggg1[amp]*z+glandau1[amp]*angle2; +// if (ctype==0) res *= gcor01[rsigmay]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmay]; +// } +// } +// else { +// if (padlength<1.1){ +// snoise2 = gnoise2; +// res = ggg2[amp]*z+glandau2[amp]*angle2; +// if (ctype==0) res *= gcor02[rsigmay]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmay]; +// } +// } +// else{ +// snoise2 = gnoise3; +// res = ggg3[amp]*z+glandau3[amp]*angle2; +// if (ctype==0) res *= gcor02[rsigmay]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmay]; +// } +// } +// } - if (ctype<0){ - res+=0.005; - res*=2.4; // overestimate error 2 times - } - res+= snoise2; +// if (ctype<0){ +// res+=0.005; +// res*=2.4; // overestimate error 2 times +// } +// res+= snoise2; - if (res<2*snoise2) - res = 2*snoise2; +// if (res<2*snoise2) +// res = 2*snoise2; - seed->SetErrorY2(res); - return res; +// seed->SetErrorY2(res); +// return res; } -Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ - // +Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){ // - //seed->SetErrorY2(0.1); - //return 0.1; - //calculate look-up table at the beginning - static Bool_t ginit = kFALSE; - static Float_t gnoise1,gnoise2,gnoise3; - static Float_t ggg1[10000]; - static Float_t ggg2[10000]; - static Float_t ggg3[10000]; - static Float_t glandau1[10000]; - static Float_t glandau2[10000]; - static Float_t glandau3[10000]; // - static Float_t gcor01[1000]; - static Float_t gcor02[1000]; - static Float_t gcorp[1000]; + // Use calibrated cluster error from OCDB // - + AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); // - if (ginit==kFALSE){ - for (Int_t i=1;i<1000;i++){ - Float_t rsigma = float(i)/100.; - gcor02[i] = TMath::Max(0.81 +TMath::Exp(6.8*(rsigma-1.2)),0.6); - gcor01[i] = TMath::Max(0.72 +TMath::Exp(2.04*(rsigma-1.2)),0.6); - gcorp[i] = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2); - } - - // - for (Int_t i=3;i<10000;i++){ - // - // - // inner sector - Float_t amp = float(i); - Float_t padlength =0.75; - gnoise1 = 0.0004/padlength; - Float_t nel = 0.268*amp; - Float_t nprim = 0.155*amp; - ggg1[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel; - glandau1[i] = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau1[i]>1) glandau1[i]=1; - glandau1[i]*=padlength*padlength/12.; - // - // outer short - padlength =1.; - gnoise2 = 0.0004/padlength; - nel = 0.3*amp; - nprim = 0.133*amp; - ggg2[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; - glandau2[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau2[i]>1) glandau2[i]=1; - glandau2[i]*=padlength*padlength/12.; - // - // - // outer long - padlength =1.5; - gnoise3 = 0.0004/padlength; - nel = 0.3*amp; - nprim = 0.133*amp; - ggg3[i] = fParam->GetDiffT()*fParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; - glandau3[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (glandau3[i]>1) glandau3[i]=1; - glandau3[i]*=padlength*padlength/12.; - // - } - ginit = kTRUE; - } - // - // - // - Int_t amp = int(TMath::Abs(cl->GetQ())); - if (amp>9999) { - seed->SetErrorY2(1.); - return 1.; - } - Float_t snoise2; - Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ())); + Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())); Int_t ctype = cl->GetType(); - Float_t padlength= GetPadPitchLength(seed->fRow); + Int_t type = (cl->GetRow()<63) ? 0: (cl->GetRow()>126) ? 1:2; // - Float_t angle2 = seed->GetSnp()*seed->GetSnp(); - // if (angle2<0.6) angle2 = 0.6; + Double_t angle2 = seed->GetSnp()*seed->GetSnp(); angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2)); - // - //cluster "quality" - Int_t rsigmaz = int(100.*cl->GetSigmaZ2()/(seed->fCurrentSigmaZ2)); - Float_t res; - // - if (fSectors==fInnerSec){ - snoise2 = gnoise1; - res = ggg1[amp]*z+glandau1[amp]*angle2; - if (ctype==0) res *= gcor01[rsigmaz]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmaz]; - } + Double_t angle = TMath::Sqrt(TMath::Abs(angle2)); + Double_t errz2 = clparam->GetError0Par(1,type, z,angle); + if (ctype<0) { + errz2+=0.5; // edge cluster } - else { - if (padlength<1.1){ - snoise2 = gnoise2; - res = ggg2[amp]*z+glandau2[amp]*angle2; - if (ctype==0) res *= gcor02[rsigmaz]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmaz]; - } - } - else{ - snoise2 = gnoise3; - res = ggg3[amp]*z+glandau3[amp]*angle2; - if (ctype==0) res *= gcor02[rsigmaz]; - if ((ctype>0)){ - res+=0.002; - res*= gcorp[rsigmaz]; - } - } - } - - if (ctype<0){ - res+=0.002; - res*=1.3; - } - if ((ctype<0) &&<70){ - res+=0.002; - res*=1.3; - } - res += snoise2; - if (res<2*snoise2) - res = 2*snoise2; - if (res>3) res =3; - seed->SetErrorZ2(res); - return res; -} - - - -/* -Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ - // + errz2*=errz2; + seed->SetErrorZ2(errz2); // - //seed->SetErrorZ2(0.1); - //return 0.1; + return errz2; - Float_t snoise2; - Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ())); - // - Float_t rsigmaz = cl->GetSigmaZ2()/(seed->fCurrentSigmaZ2); - Int_t ctype = cl->GetType(); - Float_t amp = TMath::Abs(cl->GetQ()); - - Float_t nel; - Float_t nprim; - // - Float_t landau=2 ; //landau fluctuation part - Float_t gg=2; // gg fluctuation part - Float_t padlength= GetPadPitchLength(seed->GetX()); - - if (fSectors==fInnerSec){ - snoise2 = 0.0004/padlength; - nel = 0.268*amp; - nprim = 0.155*amp; - gg = (2+0.001*nel/(padlength*padlength))/nel; - landau = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (landau>1) landau=1; - } - else { - snoise2 = 0.0004/padlength; - nel = 0.3*amp; - nprim = 0.133*amp; - gg = (2+0.0008*nel/(padlength*padlength))/nel; - landau = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; - if (landau>1) landau=1; - } - Float_t sdiff = gg*fParam->GetDiffT()*fParam->GetDiffT()*z; - // - Float_t angle2 = seed->GetSnp()*seed->GetSnp(); - angle2 = TMath::Sqrt((1-angle2)); - if (angle2<0.6) angle2 = 0.6; - //angle2 = 1; - Float_t angle = seed->GetTgl()/angle2; - Float_t angular = landau*angle*angle*padlength*padlength/12.; - Float_t res = sdiff + angular; +// //seed->SetErrorY2(0.1); +// //return 0.1; +// //calculate look-up table at the beginning +// static Bool_t ginit = kFALSE; +// static Float_t gnoise1,gnoise2,gnoise3; +// static Float_t ggg1[10000]; +// static Float_t ggg2[10000]; +// static Float_t ggg3[10000]; +// static Float_t glandau1[10000]; +// static Float_t glandau2[10000]; +// static Float_t glandau3[10000]; +// // +// static Float_t gcor01[1000]; +// static Float_t gcor02[1000]; +// static Float_t gcorp[1000]; +// // - - if ((ctype==0) && (fSectors ==fOuterSec)) - res *= 0.81 +TMath::Exp(6.8*(rsigmaz-1.2)); +// // +// if (ginit==kFALSE){ +// for (Int_t i=1;i<1000;i++){ +// Float_t rsigma = float(i)/100.; +// gcor02[i] = TMath::Max(0.81 +TMath::Exp(6.8*(rsigma-1.2)),0.6); +// gcor01[i] = TMath::Max(0.72 +TMath::Exp(2.04*(rsigma-1.2)),0.6); +// gcorp[i] = TMath::Max(TMath::Power((rsigma+0.5),1.5),1.2); +// } - if ((ctype==0) && (fSectors ==fInnerSec)) - res *= 0.72 +TMath::Exp(2.04*(rsigmaz-1.2)); - - if ((ctype>0)){ - res+=0.005; - res*= TMath::Power(rsigmaz+0.5,1.5); //0.31+0.147*ctype; - } - if (ctype<0){ - res+=0.002; - res*=1.3; - } - if ((ctype<0) &&<70){ - res+=0.002; - res*=1.3; - } - res += snoise2; - if (res<2*snoise2) - res = 2*snoise2; +// // +// for (Int_t i=3;i<10000;i++){ +// // +// // +// // inner sector +// Float_t amp = float(i); +// Float_t padlength =0.75; +// gnoise1 = 0.0004/padlength; +// Float_t nel = 0.268*amp; +// Float_t nprim = 0.155*amp; +// ggg1[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.001*nel/(padlength*padlength))/nel; +// glandau1[i] = (2.+0.12*nprim)*0.5* (2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau1[i]>1) glandau1[i]=1; +// glandau1[i]*=padlength*padlength/12.; +// // +// // outer short +// padlength =1.; +// gnoise2 = 0.0004/padlength; +// nel = 0.3*amp; +// nprim = 0.133*amp; +// ggg2[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; +// glandau2[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau2[i]>1) glandau2[i]=1; +// glandau2[i]*=padlength*padlength/12.; +// // +// // +// // outer long +// padlength =1.5; +// gnoise3 = 0.0004/padlength; +// nel = 0.3*amp; +// nprim = 0.133*amp; +// ggg3[i] = fkParam->GetDiffT()*fkParam->GetDiffT()*(2+0.0008*nel/(padlength*padlength))/nel; +// glandau3[i] = (2.+0.12*nprim)*0.5*(2.+nprim*nprim*0.001/(padlength*padlength))/nprim; +// if (glandau3[i]>1) glandau3[i]=1; +// glandau3[i]*=padlength*padlength/12.; +// // +// } +// ginit = kTRUE; +// } +// // +// // +// // +// Int_t amp = int(TMath::Abs(cl->GetQ())); +// if (amp>9999) { +// seed->SetErrorY2(1.); +// return 1.; +// } +// Float_t snoise2; +// Float_t z = TMath::Abs(fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())); +// Int_t ctype = cl->GetType(); +// Float_t padlength= GetPadPitchLength(seed->GetRow()); +// // +// Double_t angle2 = seed->GetSnp()*seed->GetSnp(); +// // if (angle2<0.6) angle2 = 0.6; +// angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2)); +// // +// //cluster "quality" +// Int_t rsigmaz = int(100.*cl->GetSigmaZ2()/(seed->GetCurrentSigmaZ2())); +// Float_t res; +// // +// if (fSectors==fInnerSec){ +// snoise2 = gnoise1; +// res = ggg1[amp]*z+glandau1[amp]*angle2; +// if (ctype==0) res *= gcor01[rsigmaz]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmaz]; +// } +// } +// else { +// if (padlength<1.1){ +// snoise2 = gnoise2; +// res = ggg2[amp]*z+glandau2[amp]*angle2; +// if (ctype==0) res *= gcor02[rsigmaz]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmaz]; +// } +// } +// else{ +// snoise2 = gnoise3; +// res = ggg3[amp]*z+glandau3[amp]*angle2; +// if (ctype==0) res *= gcor02[rsigmaz]; +// if ((ctype>0)){ +// res+=0.002; +// res*= gcorp[rsigmaz]; +// } +// } +// } - seed->SetErrorZ2(res); - return res; +// if (ctype<0){ +// res+=0.002; +// res*=1.3; +// } +// if ((ctype<0) &&<70){ +// res+=0.002; +// res*=1.3; +// } +// res += snoise2; +// if (res<2*snoise2) +// res = 2*snoise2; +// if (res>3) res =3; +// seed->SetErrorZ2(res); +// return res; } -*/ + @@ -924,11 +936,11 @@ void AliTPCtrackerMI::RotateToLocal(AliTPCseed *seed) Float_t ymax = x*TMath::Tan(0.5*fSectors->GetAlpha()); if (y > ymax) { - seed->fRelativeSector= (seed->fRelativeSector+1) % fN; + seed->SetRelativeSector((seed->GetRelativeSector()+1) % fN); if (!seed->Rotate(fSectors->GetAlpha())) return; } else if (y <-ymax) { - seed->fRelativeSector= (seed->fRelativeSector-1+fN) % fN; + seed->SetRelativeSector((seed->GetRelativeSector()-1+fN) % fN); if (!seed->Rotate(-fSectors->GetAlpha())) return; } @@ -940,7 +952,7 @@ void AliTPCtrackerMI::RotateToLocal(AliTPCseed *seed) //_____________________________________________________________________________ Double_t AliTPCtrackerMI::F1old(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t x3,Double_t y3) + Double_t x3,Double_t y3) const { //----------------------------------------------------------------- // Initial approximation of the track curvature @@ -961,7 +973,7 @@ Double_t AliTPCtrackerMI::F1old(Double_t x1,Double_t y1, //_____________________________________________________________________________ Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t x3,Double_t y3) + Double_t x3,Double_t y3) const { //----------------------------------------------------------------- // Initial approximation of the track curvature @@ -972,7 +984,7 @@ Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1, y2 -=y1; // Double_t det = x3*y2-x2*y3; - if (det==0) { + if (TMath::Abs(det)<1e-10){ return 100; } // @@ -987,7 +999,7 @@ Double_t AliTPCtrackerMI::F1(Double_t x1,Double_t y1, Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t x3,Double_t y3) + Double_t x3,Double_t y3) const { //----------------------------------------------------------------- // Initial approximation of the track curvature @@ -998,7 +1010,7 @@ Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1, y2 -=y1; // Double_t det = x3*y2-x2*y3; - if (det==0) { + if (TMath::Abs(det)<1e-10) { return 100; } // @@ -1017,7 +1029,7 @@ Double_t AliTPCtrackerMI::F2(Double_t x1,Double_t y1, //_____________________________________________________________________________ Double_t AliTPCtrackerMI::F2old(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t x3,Double_t y3) + Double_t x3,Double_t y3) const { //----------------------------------------------------------------- // Initial approximation of the track curvature times center of curvature @@ -1036,7 +1048,7 @@ Double_t AliTPCtrackerMI::F2old(Double_t x1,Double_t y1, //_____________________________________________________________________________ Double_t AliTPCtrackerMI::F3(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t z1,Double_t z2) + Double_t z1,Double_t z2) const { //----------------------------------------------------------------- // Initial approximation of the tangent of the track dip angle @@ -1047,7 +1059,7 @@ Double_t AliTPCtrackerMI::F3(Double_t x1,Double_t y1, Double_t AliTPCtrackerMI::F3n(Double_t x1,Double_t y1, Double_t x2,Double_t y2, - Double_t z1,Double_t z2, Double_t c) + Double_t z1,Double_t z2, Double_t c) const { //----------------------------------------------------------------- // Initial approximation of the tangent of the track dip angle @@ -1067,7 +1079,7 @@ Double_t AliTPCtrackerMI::F3n(Double_t x1,Double_t y1, return angle2; } -Bool_t AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z) +Bool_t AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5], Double_t &y, Double_t &z) const {//----------------------------------------------------------------- // This function find proloncation of a track to a reference plane x=x2. //----------------------------------------------------------------- @@ -1078,8 +1090,8 @@ Bool_t AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5 return kFALSE; } - Double_t c1=x[4]*x1 - x[2], r1=sqrt(1.- c1*c1); - Double_t c2=x[4]*x2 - x[2], r2=sqrt(1.- c2*c2); + Double_t c1=x[4]*x1 - x[2], r1=TMath::Sqrt((1.-c1)*(1.+c1)); + Double_t c2=x[4]*x2 - x[2], r2=TMath::Sqrt((1.-c2)*(1.+c2)); y = x[0]; z = x[1]; @@ -1102,7 +1114,7 @@ Bool_t AliTPCtrackerMI::GetProlongation(Double_t x1, Double_t x2, Double_t x[5 return kTRUE; } -Int_t AliTPCtrackerMI::LoadClusters (TTree *tree) +Int_t AliTPCtrackerMI::LoadClusters (TTree *const tree) { // // @@ -1110,14 +1122,123 @@ Int_t AliTPCtrackerMI::LoadClusters (TTree *tree) return LoadClusters(); } + +Int_t AliTPCtrackerMI::LoadClusters(const TObjArray *arr) +{ + // + // load clusters to the memory + AliTPCClustersRow *clrow = new AliTPCClustersRow("AliTPCclusterMI"); + Int_t lower = arr->LowerBound(); + Int_t entries = arr->GetEntriesFast(); + + for (Int_t i=lower; iAt(i); + if(!clrow) continue; + if(!clrow->GetArray()) continue; + + // + Int_t sec,row; + fkParam->AdjustSectorRow(clrow->GetID(),sec,row); + + for (Int_t icl=0; iclGetArray()->GetEntriesFast(); icl++){ + Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl))); + } + // + if (clrow->GetArray()->GetEntriesFast()<=0) continue; + AliTPCtrackerRow * tpcrow=0; + Int_t left=0; + if (secSetN1(clrow->GetArray()->GetEntriesFast()); + tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]); + for (Int_t j=0;jGetN1();++j) + tpcrow->SetCluster1(j, *(AliTPCclusterMI*)(clrow->GetArray()->At(j))); + } + if (left ==1){ + tpcrow->SetN2(clrow->GetArray()->GetEntriesFast()); + tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]); + for (Int_t j=0;jGetN2();++j) + tpcrow->SetCluster2(j,*(AliTPCclusterMI*)(clrow->GetArray()->At(j))); + } + clrow->GetArray()->Clear("C"); + } + // + delete clrow; + LoadOuterSectors(); + LoadInnerSectors(); + return 0; +} + +Int_t AliTPCtrackerMI::LoadClusters(const TClonesArray *arr) +{ + // + // load clusters to the memory from one + // TClonesArray + // + AliTPCclusterMI *clust=0; + Int_t count[72][96] = { {0} , {0} }; + + // loop over clusters + for (Int_t icl=0; iclGetEntriesFast(); icl++) { + clust = (AliTPCclusterMI*)arr->At(icl); + if(!clust) continue; + //printf("cluster: det %d, row %d \n", clust->GetDetector(),clust->GetRow()); + + // transform clusters + Transform(clust); + + // count clusters per pad row + count[clust->GetDetector()][clust->GetRow()]++; + } + + // insert clusters to sectors + for (Int_t icl=0; iclGetEntriesFast(); icl++) { + clust = (AliTPCclusterMI*)arr->At(icl); + if(!clust) continue; + + Int_t sec = clust->GetDetector(); + Int_t row = clust->GetRow(); + + // filter overlapping pad rows needed by HLT + if(secSetClass("AliTPCclusterMI"); - clrow->SetArray(0); - clrow->GetArray()->ExpandCreateFast(10000); + AliTPCClustersRow *clrow= new AliTPCClustersRow("AliTPCclusterMI"); // // TTree * tree = fClustersArray.GetTree(); @@ -1130,9 +1251,12 @@ Int_t AliTPCtrackerMI::LoadClusters() br->GetEntry(i); // Int_t sec,row; - fParam->AdjustSectorRow(clrow->GetID(),sec,row); + fkParam->AdjustSectorRow(clrow->GetID(),sec,row); + for (Int_t icl=0; iclGetArray()->GetEntriesFast(); icl++){ + Transform((AliTPCclusterMI*)(clrow->GetArray()->At(icl))); + } // - AliTPCRow * tpcrow=0; + AliTPCtrackerRow * tpcrow=0; Int_t left=0; if (secfN1 = clrow->GetArray()->GetEntriesFast(); - tpcrow->fClusters1 = new AliTPCclusterMI[tpcrow->fN1]; - for (Int_t i=0;ifN1;i++) - tpcrow->fClusters1[i] = *(AliTPCclusterMI*)(clrow->GetArray()->At(i)); + tpcrow->SetN1(clrow->GetArray()->GetEntriesFast()); + tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]); + for (Int_t k=0;kGetN1();++k) + tpcrow->SetCluster1(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k))); } if (left ==1){ - tpcrow->fN2 = clrow->GetArray()->GetEntriesFast(); - tpcrow->fClusters2 = new AliTPCclusterMI[tpcrow->fN2]; - for (Int_t i=0;ifN2;i++) - tpcrow->fClusters2[i] = *(AliTPCclusterMI*)(clrow->GetArray()->At(i)); + tpcrow->SetN2(clrow->GetArray()->GetEntriesFast()); + tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]); + for (Int_t k=0;kGetN2();++k) + tpcrow->SetCluster2(k,*(AliTPCclusterMI*)(clrow->GetArray()->At(k))); } } // @@ -1171,7 +1295,7 @@ void AliTPCtrackerMI::UnloadClusters() Int_t nrows = fOuterSec->GetNRows(); for (Int_t sec = 0;secfClusters1) delete []tpcrow->fClusters1; // if (tpcrow->fClusters2) delete []tpcrow->fClusters2; @@ -1182,7 +1306,7 @@ void AliTPCtrackerMI::UnloadClusters() nrows = fInnerSec->GetNRows(); for (Int_t sec = 0;secfClusters1) delete []tpcrow->fClusters1; //if (tpcrow->fClusters2) delete []tpcrow->fClusters2; @@ -1193,6 +1317,88 @@ void AliTPCtrackerMI::UnloadClusters() return ; } +void AliTPCtrackerMI::FillClusterArray(TObjArray* array) const{ + // + // Filling cluster to the array - For visualization purposes + // + Int_t nrows=0; + nrows = fOuterSec->GetNRows(); + for (Int_t sec = 0;secGetN();icl++){ + array->AddLast((TObject*)((*tpcrow)[icl])); + } + } + nrows = fInnerSec->GetNRows(); + for (Int_t sec = 0;secGetN();icl++){ + array->AddLast((TObject*)(*tpcrow)[icl]); + } + } +} + + +void AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){ + // + // + // + AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ; + if (!transform) { + AliFatal("Tranformations not in calibDB"); + } + transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam()); + Double_t x[3]={cluster->GetRow(),cluster->GetPad(),cluster->GetTimeBin()}; + Int_t i[1]={cluster->GetDetector()}; + transform->Transform(x,i,0,1); + // if (cluster->GetDetector()%36>17){ + // x[1]*=-1; + //} + + // + // in debug mode check the transformation + // + if (AliTPCReconstructor::StreamLevel()>2) { + Float_t gx[3]; + cluster->GetGlobalXYZ(gx); + Int_t event = (fEvent==NULL)? 0: fEvent->GetEventNumberInFile(); + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"Transform"<< + "event="<SetX(x[0]); + cluster->SetY(x[1]); + cluster->SetZ(x[2]); + // The old stuff: + + // + // + // + //if (!fkParam->IsGeoRead()) fkParam->ReadGeoMatrices(); + TGeoHMatrix *mat = fkParam->GetClusterMatrix(cluster->GetDetector()); + //TGeoHMatrix mat; + Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()}; + Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()}; + if (mat) mat->LocalToMaster(pos,posC); + else{ + // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX + } + cluster->SetX(posC[0]); + cluster->SetY(posC[1]); + cluster->SetZ(posC[2]); +} //_____________________________________________________________________________ Int_t AliTPCtrackerMI::LoadOuterSectors() { @@ -1203,19 +1409,19 @@ Int_t AliTPCtrackerMI::LoadOuterSectors() { UInt_t index=0; for (Int_t sec = 0;secfN1; + Int_t ncl = tpcrow->GetN1(); while (ncl--) { - AliTPCclusterMI *c= &(tpcrow->fClusters1[ncl]); + AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl)); index=(((sec2<<8)+row)<<16)+ncl; tpcrow->InsertCluster(c,index); } //right - ncl = tpcrow->fN2; + ncl = tpcrow->GetN2(); while (ncl--) { - AliTPCclusterMI *c= &(tpcrow->fClusters2[ncl]); + AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl)); index=((((sec2+fkNOS)<<8)+row)<<16)+ncl; tpcrow->InsertCluster(c,index); } @@ -1223,17 +1429,17 @@ Int_t AliTPCtrackerMI::LoadOuterSectors() { // write indexes for fast acces // for (Int_t i=0;i<510;i++) - tpcrow->fFastCluster[i]=-1; + tpcrow->SetFastCluster(i,-1); for (Int_t i=0;iGetN();i++){ Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.); - tpcrow->fFastCluster[zi]=i; // write index + tpcrow->SetFastCluster(zi,i); // write index } Int_t last = 0; for (Int_t i=0;i<510;i++){ - if (tpcrow->fFastCluster[i]<0) - tpcrow->fFastCluster[i] = last; + if (tpcrow->GetFastCluster(i)<0) + tpcrow->SetFastCluster(i,last); else - last = tpcrow->fFastCluster[i]; + last = tpcrow->GetFastCluster(i); } } fN=fkNOS; @@ -1251,19 +1457,19 @@ Int_t AliTPCtrackerMI::LoadInnerSectors() { UInt_t index=0; for (Int_t sec = 0;secfN1; + Int_t ncl = tpcrow->GetN1(); while (ncl--) { - AliTPCclusterMI *c= &(tpcrow->fClusters1[ncl]); + AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl)); index=(((sec<<8)+row)<<16)+ncl; tpcrow->InsertCluster(c,index); } //right - ncl = tpcrow->fN2; + ncl = tpcrow->GetN2(); while (ncl--) { - AliTPCclusterMI *c= &(tpcrow->fClusters2[ncl]); + AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl)); index=((((sec+fkNIS)<<8)+row)<<16)+ncl; tpcrow->InsertCluster(c,index); } @@ -1271,17 +1477,17 @@ Int_t AliTPCtrackerMI::LoadInnerSectors() { // write indexes for fast acces // for (Int_t i=0;i<510;i++) - tpcrow->fFastCluster[i]=-1; + tpcrow->SetFastCluster(i,-1); for (Int_t i=0;iGetN();i++){ Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.); - tpcrow->fFastCluster[zi]=i; // write index + tpcrow->SetFastCluster(zi,i); // write index } Int_t last = 0; for (Int_t i=0;i<510;i++){ - if (tpcrow->fFastCluster[i]<0) - tpcrow->fFastCluster[i] = last; + if (tpcrow->GetFastCluster(i)<0) + tpcrow->SetFastCluster(i,last); else - last = tpcrow->fFastCluster[i]; + last = tpcrow->GetFastCluster(i); } } @@ -1298,37 +1504,47 @@ AliTPCclusterMI *AliTPCtrackerMI::GetClusterMI(Int_t index) const { //-------------------------------------------------------------------- // Return pointer to a given cluster //-------------------------------------------------------------------- + if (index<0) return 0; // no cluster Int_t sec=(index&0xff000000)>>24; Int_t row=(index&0x00ff0000)>>16; Int_t ncl=(index&0x00007fff)>>00; - const AliTPCRow * tpcrow=0; + const AliTPCtrackerRow * tpcrow=0; AliTPCclusterMI * clrow =0; + if (sec<0 || sec>=fkNIS*4) { + AliWarning(Form("Wrong sector %d",sec)); + return 0x0; + } + if (secfN1<=ncl) return 0; - clrow = tpcrow->fClusters1; + if (tpcrow->GetN1()<=ncl) return 0; + clrow = tpcrow->GetClusters1(); } else { - if (tpcrow->fN2<=ncl) return 0; - clrow = tpcrow->fClusters2; + if (tpcrow->GetN2()<=ncl) return 0; + clrow = tpcrow->GetClusters2(); } } else { - tpcrow = &(fOuterSec[(sec-fkNIS*2)%fkNOS][row]); + AliTPCtrackerSector& tracksec = fOuterSec[(sec-fkNIS*2)%fkNOS]; + if (tracksec.GetNRows()<=row) return 0; + tpcrow = &(tracksec[row]); if (tpcrow==0) return 0; if (sec-2*fkNISfN1<=ncl) return 0; - clrow = tpcrow->fClusters1; + if (tpcrow->GetN1()<=ncl) return 0; + clrow = tpcrow->GetClusters1(); } else { - if (tpcrow->fN2<=ncl) return 0; - clrow = tpcrow->fClusters2; + if (tpcrow->GetN2()<=ncl) return 0; + clrow = tpcrow->GetClusters2(); } } @@ -1344,6 +1560,8 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) { //----------------------------------------------------------------- // Double_t x= GetXrow(nr), ymax=GetMaxY(nr); + // + // AliTPCclusterMI *cl=0; Int_t tpcindex= t.GetClusterIndex2(nr); // @@ -1356,9 +1574,9 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) { // if (tpcindex==-1) return 0; //track in dead zone if (tpcindex>0){ // - cl = t.fClusterPointer[nr]; + cl = t.GetClusterPointer(nr); if ( (cl==0) ) cl = GetClusterMI(tpcindex); - t.fCurrentClusterIndex1 = tpcindex; + t.SetCurrentClusterIndex1(tpcindex); } if (cl){ Int_t relativesector = ((tpcindex&0xff000000)>>24)%18; // if previously accepted cluster in different sector @@ -1369,41 +1587,46 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) { if (TMath::Abs(angle-t.GetAlpha())>0.001){ Double_t rotation = angle-t.GetAlpha(); - t.fRelativeSector= relativesector; - t.Rotate(rotation); + t.SetRelativeSector(relativesector); + if (!t.Rotate(rotation)) return 0; } - t.PropagateTo(x); + if (!t.PropagateTo(x)) return 0; // - t.fCurrentCluster = cl; - t.fRow = nr; - Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.); + t.SetCurrentCluster(cl); + t.SetRow(nr); + Int_t accept = AcceptCluster(&t,t.GetCurrentCluster()); if ((tpcindex&0x8000)==0) accept =0; if (accept<3) { //if founded cluster is acceptible if (cl->IsUsed(11)) { // id cluster is shared inrease uncertainty - t.fErrorY2 += 0.03; - t.fErrorZ2 += 0.03; - t.fErrorY2 *= 3; - t.fErrorZ2 *= 3; + t.SetErrorY2(t.GetErrorY2()+0.03); + t.SetErrorZ2(t.GetErrorZ2()+0.03); + t.SetErrorY2(t.GetErrorY2()*3); + t.SetErrorZ2(t.GetErrorZ2()*3); } - t.fNFoundable++; + t.SetNFoundable(t.GetNFoundable()+1); UpdateTrack(&t,accept); return 1; } } } - if (fIteration>1) {t.fNFoundable++; return 0;} // not look for new cluster during refitting + if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0; // cut on angle + if (fIteration>1 && IsFindable(t)){ + // not look for new cluster during refitting + t.SetNFoundable(t.GetNFoundable()+1); + return 0; + } // UInt_t index=0; - if (TMath::Abs(t.GetSnp())>0.95 || TMath::Abs(x*t.GetC()-t.GetEta())>0.95) return 0; + // if (TMath::Abs(t.GetSnp())>0.95 || TMath::Abs(x*t.GetC()-t.GetEta())>0.95) return 0;// patch 28 fev 06 Double_t y=t.GetYat(x); if (TMath::Abs(y)>ymax){ if (y > ymax) { - t.fRelativeSector= (t.fRelativeSector+1) % fN; + t.SetRelativeSector((t.GetRelativeSector()+1) % fN); if (!t.Rotate(fSectors->GetAlpha())) return 0; } else if (y <-ymax) { - t.fRelativeSector= (t.fRelativeSector-1+fN) % fN; + t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN); if (!t.Rotate(-fSectors->GetAlpha())) return 0; } @@ -1411,25 +1634,39 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) { } // if (!t.PropagateTo(x)) { - if (fIteration==0) t.fRemoval = 10; + if (fIteration==0) t.SetRemoval(10); return 0; } y=t.GetY(); Double_t z=t.GetZ(); // - const AliTPCRow &krow=GetRow(t.fRelativeSector,nr); + + if (!IsActive(t.GetRelativeSector(),nr)) { + t.SetInDead(kTRUE); + t.SetClusterIndex2(nr,-1); + return 0; + } + //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha())); + Bool_t isActive = IsActive(t.GetRelativeSector(),nr); + Bool_t isActive2 = (nr>=fInnerSec->GetNRows()) ? fOuterSec[t.GetRelativeSector()][nr-fInnerSec->GetNRows()].GetN()>0:fInnerSec[t.GetRelativeSector()][nr].GetN()>0; + + if (!isActive || !isActive2) return 0; + + const AliTPCtrackerRow &krow=GetRow(t.GetRelativeSector(),nr); if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0; Double_t roady =1.; Double_t roadz = 1.; // - if (TMath::Abs(TMath::Abs(y)-ymax)GetZLength() ) t.fNFoundable++; + if (IsFindable(t)) + // if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)GetZLength(0) && (TMath::Abs(t.GetSnp())IsUsed(10)) return 0; - Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.); + Int_t accept = AcceptCluster(&t,t.GetCurrentCluster()); if (fIteration==2&&cl->IsUsed(11)) { - t.fErrorY2 += 0.03; - t.fErrorZ2 += 0.03; - t.fErrorY2 *= 3; - t.fErrorZ2 *= 3; + t.SetErrorY2(t.GetErrorY2()+0.03); + t.SetErrorZ2(t.GetErrorZ2()+0.03); + t.SetErrorY2(t.GetErrorY2()*3); + t.SetErrorZ2(t.GetErrorZ2()*3); } /* if (t.fCurrentCluster->IsUsed(10)){ @@ -1465,89 +1702,12 @@ Int_t AliTPCtrackerMI::FollowToNext(AliTPCseed& t, Int_t nr) { if (accept<3) UpdateTrack(&t,accept); } else { - if ( fIteration==0 && t.fNFoundable*0.5 > t.GetNumberOfClusters()) t.fRemoval=10; + if ( fIteration==0 && t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) t.SetRemoval(10); } return 1; } -Int_t AliTPCtrackerMI::FollowToNextFast(AliTPCseed& t, Int_t nr) { - //----------------------------------------------------------------- - // This function tries to find a track prolongation to next pad row - //----------------------------------------------------------------- - // - Double_t x= GetXrow(nr), ymax=GetMaxY(nr); - Double_t y,z; - if (!t.GetProlongation(x,y,z)) { - t.fRemoval = 10; - return 0; - } - // - // - if (TMath::Abs(y)>ymax){ - - if (y > ymax) { - t.fRelativeSector= (t.fRelativeSector+1) % fN; - if (!t.Rotate(fSectors->GetAlpha())) - return 0; - } else if (y <-ymax) { - t.fRelativeSector= (t.fRelativeSector-1+fN) % fN; - if (!t.Rotate(-fSectors->GetAlpha())) - return 0; - } - if (!t.PropagateTo(x)) { - return 0; - } - t.GetProlongation(x,y,z); - } - // - // update current shape info every 3 pad-row - if ( (nr%6==0) || t.GetNumberOfClusters()<2 || (t.fCurrentSigmaY2<0.0001) ){ - // t.fCurrentSigmaY = GetSigmaY(&t); - //t.fCurrentSigmaZ = GetSigmaZ(&t); - GetShape(&t,nr); - } - // - AliTPCclusterMI *cl=0; - UInt_t index=0; - - - //Int_t nr2 = nr; - const AliTPCRow &krow=GetRow(t.fRelativeSector,nr); - if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0; - Double_t roady =1.; - Double_t roadz = 1.; - // - Int_t row = nr; - if (TMath::Abs(TMath::Abs(y)-ymax)(AliTPCReconstructor::GetCtgRange()*x+10)) t.SetClusterIndex2(row,-1); - } - //calculate - - if ((cl==0)&&(krow)) { - // cl = krow.FindNearest2(y+10,z,roady,roadz,index); - cl = krow.FindNearest2(y,z,roady,roadz,index); - - if (cl) t.fCurrentClusterIndex1 = krow.GetIndex(index); - } - - if (cl) { - t.fCurrentCluster = cl; - // Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.); - //if (accept<3){ - t.SetClusterIndex2(row,index); - t.fClusterPointer[row] = cl; - //} - } - return 1; -} - //_________________________________________________________________________ @@ -1558,20 +1718,21 @@ Bool_t AliTPCtrackerMI::GetTrackPoint(Int_t index, AliTrackPoint &p ) const AliTPCclusterMI *cl = GetClusterMI(index); if (!cl) return kFALSE; Int_t sector = (index&0xff000000)>>24; - Int_t row = (index&0x00ff0000)>>16; + // Int_t row = (index&0x00ff0000)>>16; Float_t xyz[3]; - xyz[0] = fParam->GetPadRowRadii(sector,row); + // xyz[0] = fkParam->GetPadRowRadii(sector,row); + xyz[0] = cl->GetX(); xyz[1] = cl->GetY(); xyz[2] = cl->GetZ(); Float_t sin,cos; - fParam->AdjustCosSin(sector,cos,sin); + fkParam->AdjustCosSin(sector,cos,sin); Float_t x = cos*xyz[0]-sin*xyz[1]; Float_t y = cos*xyz[1]+sin*xyz[0]; Float_t cov[6]; Float_t sigmaY2 = 0.027*cl->GetSigmaY2(); - if (sector < fParam->GetNInnerSector()) sigmaY2 *= 2.07; + if (sector < fkParam->GetNInnerSector()) sigmaY2 *= 2.07; Float_t sigmaZ2 = 0.066*cl->GetSigmaZ2(); - if (sector < fParam->GetNInnerSector()) sigmaZ2 *= 1.77; + if (sector < fkParam->GetNInnerSector()) sigmaZ2 *= 1.77; cov[0] = sin*sin*sigmaY2; cov[1] = -sin*cos*sigmaY2; cov[2] = 0.; @@ -1579,17 +1740,17 @@ Bool_t AliTPCtrackerMI::GetTrackPoint(Int_t index, AliTrackPoint &p ) const cov[4] = 0.; cov[5] = sigmaZ2; p.SetXYZ(x,y,xyz[2],cov); - AliAlignObj::ELayerID iLayer; + AliGeomManager::ELayerID iLayer; Int_t idet; - if (sector < fParam->GetNInnerSector()) { - iLayer = AliAlignObj::kTPC1; + if (sector < fkParam->GetNInnerSector()) { + iLayer = AliGeomManager::kTPC1; idet = sector; } else { - iLayer = AliAlignObj::kTPC2; - idet = sector - fParam->GetNInnerSector(); + iLayer = AliGeomManager::kTPC2; + idet = sector - fkParam->GetNInnerSector(); } - UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,idet); + UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,idet); p.SetVolumeID(volid); return kTRUE; } @@ -1600,22 +1761,22 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t, Int_t nr) { //----------------------------------------------------------------- // This function tries to find a track prolongation to next pad row //----------------------------------------------------------------- - t.fCurrentCluster = 0; - t.fCurrentClusterIndex1 = 0; + t.SetCurrentCluster(0); + t.SetCurrentClusterIndex1(0); Double_t xt=t.GetX(); Int_t row = GetRowNumber(xt)-1; Double_t ymax= GetMaxY(nr); if (row < nr) return 1; // don't prolongate if not information until now - - if (TMath::Abs(t.GetSnp())>0.9 && t.GetNumberOfClusters()>40. && fIteration!=2) { - t.fRemoval =10; - return 0; // not prolongate strongly inclined tracks - } - if (TMath::Abs(t.GetSnp())>0.95) { - t.fRemoval =10; - return 0; // not prolongate strongly inclined tracks - } +// if (TMath::Abs(t.GetSnp())>0.9 && t.GetNumberOfClusters()>40. && fIteration!=2) { +// t.fRemoval =10; +// return 0; // not prolongate strongly inclined tracks +// } +// if (TMath::Abs(t.GetSnp())>0.95) { +// t.fRemoval =10; +// return 0; // not prolongate strongly inclined tracks +// }// patch 28 fev 06 Double_t x= GetXrow(nr); Double_t y,z; @@ -1630,11 +1791,11 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t, Int_t nr) { if (TMath::Abs(y)>ymax){ if (y > ymax) { - t.fRelativeSector= (t.fRelativeSector+1) % fN; + t.SetRelativeSector((t.GetRelativeSector()+1) % fN); if (!t.Rotate(fSectors->GetAlpha())) return 0; } else if (y <-ymax) { - t.fRelativeSector= (t.fRelativeSector-1+fN) % fN; + t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN); if (!t.Rotate(-fSectors->GetAlpha())) return 0; } @@ -1645,23 +1806,33 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t, Int_t nr) { //y = t.GetY(); } // + if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0; + + if (!IsActive(t.GetRelativeSector(),nr)) { + t.SetInDead(kTRUE); + t.SetClusterIndex2(nr,-1); + return 0; + } + //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha())); - AliTPCRow &krow=GetRow(t.fRelativeSector,nr); + AliTPCtrackerRow &krow=GetRow(t.GetRelativeSector(),nr); - if (TMath::Abs(TMath::Abs(y)-ymax)0) && (index&0x8000)==0){ - cl = t.fClusterPointer[nr]; + cl = t.GetClusterPointer(nr); if ( (cl==0) && (index>0)) cl = GetClusterMI(index); - t.fCurrentClusterIndex1 = index; + t.SetCurrentClusterIndex1(index); if (cl) { - t.fCurrentCluster = cl; + t.SetCurrentCluster(cl); return 1; } } @@ -1695,8 +1866,8 @@ Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t, Int_t nr) { cl = krow.FindNearest2(y,z,roady,roadz,uindex); } - if (cl) t.fCurrentClusterIndex1 = krow.GetIndex(uindex); - t.fCurrentCluster = cl; + if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(uindex)); + t.SetCurrentCluster(cl); return 1; } @@ -1709,18 +1880,18 @@ Int_t AliTPCtrackerMI::FollowToNextCluster(AliTPCseed & t, Int_t nr) { //update error according neighborhoud - if (t.fCurrentCluster) { - t.fRow = nr; - Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.); + if (t.GetCurrentCluster()) { + t.SetRow(nr); + Int_t accept = AcceptCluster(&t,t.GetCurrentCluster()); - if (t.fCurrentCluster->IsUsed(10)){ + if (t.GetCurrentCluster()->IsUsed(10)){ // // // t.fErrorZ2*=2; // t.fErrorY2*=2; - t.fNShared++; - if (t.fNShared>0.7*t.GetNumberOfClusters()) { - t.fRemoval =10; + t.SetNShared(t.GetNShared()+1); + if (t.GetNShared()>0.7*t.GetNumberOfClusters()) { + t.SetRemoval(10); return 0; } } @@ -1729,10 +1900,10 @@ Int_t AliTPCtrackerMI::FollowToNextCluster(AliTPCseed & t, Int_t nr) { } else { if (fIteration==0){ - if ( ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)&& t.GetNumberOfClusters()>18) t.fRemoval=10; - if ( t.GetChi2()/t.GetNumberOfClusters()>6 &&t.GetNumberOfClusters()>18) t.fRemoval=10; + if ( ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)&& t.GetNumberOfClusters()>18) t.SetRemoval(10); + if ( t.GetChi2()/t.GetNumberOfClusters()>6 &&t.GetNumberOfClusters()>18) t.SetRemoval(10); - if (( (t.fNFoundable*0.5 > t.GetNumberOfClusters()) || t.fNoCluster>15)) t.fRemoval=10; + if (( (t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) || t.GetNoCluster()>15)) t.SetRemoval(10); } } return 1; @@ -1751,7 +1922,7 @@ Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) { if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); // - t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN; + t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN); Int_t first = GetRowNumber(xt)-1; for (Int_t nr= first; nr>=rf; nr-=step) { @@ -1762,7 +1933,7 @@ Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) { if (index==0) break; if (index<0) continue; // - AliESDkink * kink = fEvent->GetKink(index-1); + AliKink * kink = (AliKink*)fEvent->GetKink(index-1); if (!kink){ printf("PROBLEM\n"); } @@ -1792,27 +1963,6 @@ Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) { } -//_____________________________________________________________________________ -Int_t AliTPCtrackerMI::FollowProlongationFast(AliTPCseed& t, Int_t rf, Int_t step) { - //----------------------------------------------------------------- - // This function tries to find a track prolongation. - //----------------------------------------------------------------- - Double_t xt=t.GetX(); - // - Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift(); - if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); - if (alpha < 0. ) alpha += 2.*TMath::Pi(); - t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN; - - for (Int_t nr=GetRowNumber(xt)-1; nr>=rf; nr-=step) { - - if (FollowToNextFast(t,nr)==0) - if (!t.IsActive()) return 0; - - } - return 1; -} - @@ -1826,21 +1976,21 @@ Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf) { Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift(); if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); - t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN; + t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN); - Int_t first = t.fFirstPoint; + Int_t first = t.GetFirstPoint(); if (first0.95)) break; + // if ( (TMath::Abs(t.GetSnp())>0.95)) break;//patch 28 fev 06 if (t.GetKinkIndexes()[0]<0){ for (Int_t i=0;i<3;i++){ Int_t index = t.GetKinkIndexes()[i]; if (index==0) break; if (index>0) continue; index = TMath::Abs(index); - AliESDkink * kink = fEvent->GetKink(index-1); + AliKink * kink = (AliKink*)fEvent->GetKink(index-1); if (!kink){ printf("PROBLEM\n"); } @@ -1860,6 +2010,7 @@ Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf) { fSectors = fInnerSec; else fSectors = fOuterSec; + FollowToNext(t,nr); } return 1; @@ -1886,8 +2037,8 @@ Float_t AliTPCtrackerMI::OverlapFactor(AliTPCseed * s1, AliTPCseed * s2, Int_t & if (distance>4.) return 0; // if there are far away - not overlap - to reduce combinatorics // Int_t offset =0; - Int_t firstpoint = TMath::Min(s1->fFirstPoint,s2->fFirstPoint); - Int_t lastpoint = TMath::Max(s1->fLastPoint,s2->fLastPoint); + Int_t firstpoint = TMath::Min(s1->GetFirstPoint(),s2->GetFirstPoint()); + Int_t lastpoint = TMath::Max(s1->GetLastPoint(),s2->GetLastPoint()); if (lastpoint>160) lastpoint =160; if (firstpoint<0) @@ -1916,31 +2067,32 @@ void AliTPCtrackerMI::SignShared(AliTPCseed * s1, AliTPCseed * s2) { // // - if (TMath::Abs(s1->GetC()-s2->GetC())>0.004) return; - if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>0.6) return; - - Float_t dz2 =(s1->GetZ() - s2->GetZ()); - dz2*=dz2; - Float_t dy2 =(s1->GetY() - s2->GetY()); - dy2*=dy2; - Float_t distance = dz2+dy2; - if (distance>325.) return ; // if there are far away - not overlap - to reduce combinatorics + Float_t thetaCut = 0.2;//+10.*TMath::Sqrt(s1->GetSigmaTglZ()+ s2->GetSigmaTglZ()); + if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>thetaCut) return; + Float_t minCl = TMath::Min(s1->GetNumberOfClusters(),s2->GetNumberOfClusters()); + Int_t cutN0 = TMath::Max(5,TMath::Nint(0.1*minCl)); // Int_t sumshared=0; // - Int_t firstpoint = TMath::Max(s1->fFirstPoint,s2->fFirstPoint); - Int_t lastpoint = TMath::Min(s1->fLastPoint,s2->fLastPoint); + //Int_t firstpoint = TMath::Max(s1->GetFirstPoint(),s2->GetFirstPoint()); + //Int_t lastpoint = TMath::Min(s1->GetLastPoint(),s2->GetLastPoint()); + Int_t firstpoint = 0; + Int_t lastpoint = 160; // - if (firstpoint>=lastpoint-5) return;; + // if (firstpoint>=lastpoint-5) return;; for (Int_t i=firstpoint;iGetClusterIndex2(i)&0xFFFF8FFF)==(s2->GetClusterIndex2(i)&0xFFFF8FFF) && s1->GetClusterIndex2(i)>0) { if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) { sumshared++; + s1->SetSharedMapBit(i, kTRUE); + s2->SetSharedMapBit(i, kTRUE); } + if (s1->GetClusterIndex2(i)>0) + s1->SetClusterMapBit(i, kTRUE); } - if (sumshared>4){ + if (sumshared>cutN0){ // sign clusters // for (Int_t i=firstpoint;iGetTrackPoint(i); AliTPCTrackerPoint *p2 = s2->GetTrackPoint(i);; if (s1->IsActive()&&s2->IsActive()){ - p1->fIsShared = kTRUE; - p2->fIsShared = kTRUE; + p1->SetShared(kTRUE); + p2->SetShared(kTRUE); } } } } // - if (sumshared>10){ + if (sumshared>cutN0){ for (Int_t i=0;i<4;i++){ - if (s1->fOverlapLabels[3*i]==0){ - s1->fOverlapLabels[3*i] = s2->GetLabel(); - s1->fOverlapLabels[3*i+1] = sumshared; - s1->fOverlapLabels[3*i+2] = s2->GetUniqueID(); + if (s1->GetOverlapLabel(3*i)==0){ + s1->SetOverlapLabel(3*i, s2->GetLabel()); + s1->SetOverlapLabel(3*i+1,sumshared); + s1->SetOverlapLabel(3*i+2,s2->GetUniqueID()); break; } } for (Int_t i=0;i<4;i++){ - if (s2->fOverlapLabels[3*i]==0){ - s2->fOverlapLabels[3*i] = s1->GetLabel(); - s2->fOverlapLabels[3*i+1] = sumshared; - s2->fOverlapLabels[3*i+2] = s1->GetUniqueID(); + if (s2->GetOverlapLabel(3*i)==0){ + s2->SetOverlapLabel(3*i, s1->GetLabel()); + s2->SetOverlapLabel(3*i+1,sumshared); + s2->SetOverlapLabel(3*i+2,s1->GetUniqueID()); break; } } } - } void AliTPCtrackerMI::SignShared(TObjArray * arr) @@ -1986,10 +2137,10 @@ void AliTPCtrackerMI::SignShared(TObjArray * arr) AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); if (!pt) continue; //if (pt) RotateToLocal(pt); - pt->fSort = 0; + pt->SetSort(0); } arr->UnSort(); - arr->Sort(); // sorting according z + arr->Sort(); // sorting according relative sectors arr->Expand(arr->GetEntries()); // // @@ -1998,199 +2149,65 @@ void AliTPCtrackerMI::SignShared(TObjArray * arr) AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); if (!pt) continue; for (Int_t j=0;j<=12;j++){ - pt->fOverlapLabels[j] =0; + pt->SetOverlapLabel(j,0); } } for (Int_t i=0; iUncheckedAt(i); if (!pt) continue; - if (pt->fRemoval>10) continue; + if (pt->GetRemoval()>10) continue; for (Int_t j=i+1; jUncheckedAt(j); + if (TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>1) continue; // if (pt2){ - if (pt2->fRemoval<=10) { - if ( TMath::Abs(pt->fRelativeSector-pt2->fRelativeSector)>0) break; + if (pt2->GetRemoval()<=10) { + //if ( TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>0) break; SignShared(pt,pt2); } } } } -void AliTPCtrackerMI::RemoveDouble(TObjArray * arr, Float_t factor1, Float_t factor2, Int_t removalindex) -{ - // - //sort trackss according sectors - // - if (fDebug&1) { - Info("RemoveDouble","Number of tracks before double removal- %d\n",arr->GetEntries()); - } - // - for (Int_t i=0; iGetEntriesFast(); i++) { - AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); - if (!pt) continue; - pt->fSort = 0; - } - arr->UnSort(); - arr->Sort(); // sorting according z - arr->Expand(arr->GetEntries()); - // - //reset overlap labels - // - Int_t nseed=arr->GetEntriesFast(); - for (Int_t i=0; iUncheckedAt(i); - if (!pt) continue; - pt->SetUniqueID(i); - for (Int_t j=0;j<=12;j++){ - pt->fOverlapLabels[j] =0; - } - } - // - //sign shared tracks - for (Int_t i=0; iUncheckedAt(i); - if (!pt) continue; - if (pt->fRemoval>10) continue; - Float_t deltac = pt->GetC()*0.1; - for (Int_t j=i+1; jUncheckedAt(j); - // if (pt2){ - if (pt2->fRemoval<=10) { - if ( TMath::Abs(pt->fRelativeSector-pt2->fRelativeSector)>0) break; - if (TMath::Abs(pt->GetC() -pt2->GetC())>deltac) continue; - if (TMath::Abs(pt->GetTgl()-pt2->GetTgl())>0.05) continue; - // - SignShared(pt,pt2); - } - } - } - // - // remove highly shared tracks - for (Int_t i=0; iUncheckedAt(i); - if (!pt) continue; - if (pt->fRemoval>10) continue; - // - Int_t sumshared =0; - for (Int_t j=0;j<4;j++){ - sumshared = pt->fOverlapLabels[j*3+1]; - } - Float_t factor = factor1; - if (pt->fRemoval>0) factor = factor2; - if (sumshared/pt->GetNumberOfClusters()>factor){ - for (Int_t j=0;j<4;j++){ - if (pt->fOverlapLabels[3*j]==0) continue; - if (pt->fOverlapLabels[3*j+1]<5) continue; - if (pt->fRemoval==removalindex) continue; - AliTPCseed * pt2 = (AliTPCseed*)arr->UncheckedAt(pt->fOverlapLabels[3*j+2]); - if (!pt2) continue; - if (pt2->GetSigma2C()GetSigma2C()){ - // pt->fRemoval = removalindex; - delete arr->RemoveAt(i); - break; - } - } - } - } - arr->Compress(); - if (fDebug&1) { - Info("RemoveDouble","Number of tracks after double removal- %d\n",arr->GetEntries()); - } -} - - - - - void AliTPCtrackerMI::SortTracks(TObjArray * arr, Int_t mode) const -{ - // - //sort tracks in array according mode criteria - Int_t nseed = arr->GetEntriesFast(); - for (Int_t i=0; iUncheckedAt(i); - if (!pt) { - continue; - } - pt->fSort = mode; - } - arr->UnSort(); - arr->Sort(); -} - -void AliTPCtrackerMI::RemoveUsed(TObjArray * arr, Float_t factor1, Float_t factor2, Int_t removalindex) -{ - - //Loop over all tracks and remove "overlaps" - // - // - Int_t nseed = arr->GetEntriesFast(); - Int_t good =0; - - for (Int_t i=0; iUncheckedAt(i); - if (!pt) { - delete arr->RemoveAt(i); - } - else{ - pt->fSort =1; - pt->fBSigned = kFALSE; - } - } - arr->Compress(); - nseed = arr->GetEntriesFast(); - arr->UnSort(); - arr->Sort(); - // - //unsign used - UnsignClusters(); +{ // + //sort tracks in array according mode criteria + Int_t nseed = arr->GetEntriesFast(); for (Int_t i=0; iUncheckedAt(i); if (!pt) { continue; - } - Int_t found,foundable,shared; - if (pt->IsActive()) - pt->GetClusterStatistic(0,160,found, foundable,shared,kFALSE); - else - pt->GetClusterStatistic(0,160,found, foundable,shared,kTRUE); - // - Double_t factor = factor2; - if (pt->fBConstrain) factor = factor1; - - if ((Float_t(shared)/Float_t(found))>factor){ - pt->Desactivate(removalindex); - continue; - } - - good++; - for (Int_t i=0; i<160; i++) { - Int_t index=pt->GetClusterIndex2(i); - if (index<0 || index&0x8000 ) continue; - AliTPCclusterMI *c= pt->fClusterPointer[i]; - if (!c) continue; - // if (!c->IsUsed(10)) c->Use(10); - //if (pt->IsActive()) - c->Use(10); - //else - // c->Use(5); } - - } - fNtracks = good; - if (fDebug>0){ - Info("RemoveUsed","\n*****\nNumber of good tracks after shared removal\t%d\n",fNtracks); + pt->SetSort(mode); } + arr->UnSort(); + arr->Sort(); } void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t factor2, Int_t minimal) { - - //Loop over all tracks and remove "overlaps" // + // Loop over all tracks and remove overlaped tracks (with lower quality) + // Algorithm: + // 1. Unsign clusters + // 2. Sort tracks according quality + // Quality is defined by the number of cluster between first and last points + // + // 3. Loop over tracks - decreasing quality order + // a.) remove - If the fraction of shared cluster less than factor (1- n or 2) + // b.) remove - If the minimal number of clusters less than minimal and not ITS + // c.) if track accepted - sign clusters + // + //Called in - AliTPCtrackerMI::Clusters2Tracks() + // - AliTPCtrackerMI::PropagateBack() + // - AliTPCtrackerMI::RefitInward() + // + // Arguments: + // factor1 - factor for constrained + // factor2 - for non constrained tracks + // if (Float_t(shared+1)/Float_t(found+1)>factor) - DELETE // UnsignClusters(); // @@ -2209,15 +2226,18 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac pt->UpdatePoints(); //select first last max dens points Float_t * points = pt->GetPoints(); if (points[3]<0.8) quality[i] =-1; - // quality[i] = (points[2]-points[0])+pt->GetNumberOfClusters(); + //prefer high momenta tracks if overlaps + quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5); } TMath::Sort(nseed,quality,indexes); // // for (Int_t itrack=0; itrackUncheckedAt(trackindex); + AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(trackindex); + if (!pt) continue; + // if (quality[trackindex]<0){ if (pt) { delete arr->RemoveAt(trackindex); @@ -2228,40 +2248,58 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac continue; } // + // Int_t first = Int_t(pt->GetPoints()[0]); Int_t last = Int_t(pt->GetPoints()[2]); - Double_t factor = (pt->fBConstrain) ? factor1: factor2; + Double_t factor = (pt->GetBConstrain()) ? factor1: factor2; // Int_t found,foundable,shared; - pt->GetClusterStatistic(first,last, found, foundable,shared,kFALSE); - Float_t sharedfactor = Float_t(shared+1)/Float_t(found+1); + pt->GetClusterStatistic(first,last, found, foundable,shared,kFALSE); // better to get statistic in "high-dens" region do't use full track as in line bellow + // pt->GetClusterStatistic(0,160, found, foundable,shared,kFALSE); Bool_t itsgold =kFALSE; - if (pt->fEsd){ - UInt_t dummy[12]; - if (pt->fEsd->GetITSclusters(dummy)>4) itsgold= kTRUE; + if (pt->GetESD()){ + Int_t dummy[12]; + if (pt->GetESD()->GetITSclusters(dummy)>4) itsgold= kTRUE; } if (!itsgold){ // if (Float_t(shared+1)/Float_t(found+1)>factor){ if (pt->GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks + if( AliTPCReconstructor::StreamLevel()>3){ + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"RemoveUsed"<< + "iter="<RemoveAt(trackindex); continue; } if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks + if( AliTPCReconstructor::StreamLevel()>3){ + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"RemoveShort"<< + "iter="<RemoveAt(trackindex); continue; } } good++; - if (sharedfactor>0.4) continue; + //if (sharedfactor>0.4) continue; if (pt->GetKinkIndexes()[0]>0) continue; + //Remove tracks with undefined properties - seems + if (pt->GetSigmaY2()GetClusterIndex2(i); // if (index<0 || index&0x8000 ) continue; if (index<0 || index&0x8000 ) continue; - AliTPCclusterMI *c= pt->fClusterPointer[i]; + AliTPCclusterMI *c= pt->GetClusterPointer(i); if (!c) continue; c->Use(10); } @@ -2274,6 +2312,88 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac delete []indexes; } +void AliTPCtrackerMI::DumpClusters(Int_t iter, TObjArray *trackArray) +{ + // + // Dump clusters after reco + // signed and unsigned cluster can be visualized + // 1. Unsign all cluster + // 2. Sign all used clusters + // 3. Dump clusters + UnsignClusters(); + Int_t nseed = trackArray->GetEntries(); + for (Int_t i=0; iUncheckedAt(i); + if (!pt) { + continue; + } + Bool_t isKink=pt->GetKinkIndex(0)!=0; + for (Int_t j=0; j<160; ++j) { + Int_t index=pt->GetClusterIndex2(j); + if (index<0) continue; + AliTPCclusterMI *c= pt->GetClusterPointer(j); + if (!c) continue; + if (isKink) c->Use(100); // kink + c->Use(10); // by default usage 10 + } + } + // + + for (Int_t sec=0;secGetNRows();row++){ + AliTPCclusterMI *cl = fInnerSec[sec][row].GetClusters1(); + for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++){ + Float_t gx[3]; cl[icl].GetGlobalXYZ(gx); + (*fDebugStreamer)<<"clDump"<< + "iter="<GetNRows();row++){ + AliTPCclusterMI *cl = fOuterSec[sec][row].GetClusters1(); + for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++){ + Float_t gx[3]; cl[icl].GetGlobalXYZ(gx); + (*fDebugStreamer)<<"clDump"<< + "iter="<GetNRows();row++){ - AliTPCclusterMI *cl = fInnerSec[sec][row].fClusters1; - for (Int_t icl =0;icl< fInnerSec[sec][row].fN1;icl++) + AliTPCclusterMI *cl = fInnerSec[sec][row].GetClusters1(); + for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++) // if (cl[icl].IsUsed(10)) cl[icl].Use(-1); - cl = fInnerSec[sec][row].fClusters2; - for (Int_t icl =0;icl< fInnerSec[sec][row].fN2;icl++) + cl = fInnerSec[sec][row].GetClusters2(); + for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++) //if (cl[icl].IsUsed(10)) cl[icl].Use(-1); } @@ -2295,12 +2415,12 @@ void AliTPCtrackerMI::UnsignClusters() for (Int_t sec=0;secGetNRows();row++){ - AliTPCclusterMI *cl = fOuterSec[sec][row].fClusters1; - for (Int_t icl =0;icl< fOuterSec[sec][row].fN1;icl++) + AliTPCclusterMI *cl = fOuterSec[sec][row].GetClusters1(); + for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++) //if (cl[icl].IsUsed(10)) cl[icl].Use(-1); - cl = fOuterSec[sec][row].fClusters2; - for (Int_t icl =0;icl< fOuterSec[sec][row].fN2;icl++) + cl = fOuterSec[sec][row].GetClusters2(); + for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++) //if (cl[icl].IsUsed(10)) cl[icl].Use(-1); } @@ -2310,7 +2430,7 @@ void AliTPCtrackerMI::UnsignClusters() -void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fdensity) +void AliTPCtrackerMI::SignClusters(const TObjArray * arr, Float_t fnumber, Float_t fdensity) { // //sign clusters to be "used" @@ -2337,7 +2457,7 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde continue; } if (!(pt->IsActive())) continue; - Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->fNFoundable); + Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable()); if ( (dens>0.7) && (pt->GetNumberOfClusters()>70)){ sumdens += dens; sumdens2+= dens*dens; @@ -2365,13 +2485,22 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde meanchi = sumchi/sum; // sdensity = sumdens2/sum-mdensity*mdensity; - sdensity = TMath::Sqrt(sdensity); + if (sdensity >= 0) + sdensity = TMath::Sqrt(sdensity); + else + sdensity = 0.1; // smeann = sumn2/sum-meann*meann; - smeann = TMath::Sqrt(smeann); + if (smeann >= 0) + smeann = TMath::Sqrt(smeann); + else + smeann = 10; // smeanchi = sumchi2/sum - meanchi*meanchi; - smeanchi = TMath::Sqrt(smeanchi); + if (smeanchi >= 0) + smeanchi = TMath::Sqrt(smeanchi); + else + smeanchi = 0.4; } @@ -2382,8 +2511,8 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde if (!pt) { continue; } - if (pt->fBSigned) continue; - if (pt->fBConstrain) continue; + if (pt->GetBSigned()) continue; + if (pt->GetBConstrain()) continue; //if (!(pt->IsActive())) continue; /* Int_t found,foundable,shared; @@ -2396,9 +2525,9 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde } */ Bool_t isok =kFALSE; - if ( (pt->fNShared/pt->GetNumberOfClusters()<0.5) &&pt->GetNumberOfClusters()>60) + if ( (pt->GetNShared()/pt->GetNumberOfClusters()<0.5) &&pt->GetNumberOfClusters()>60) isok = kTRUE; - if ((TMath::Abs(1/pt->GetC())<100.) && (pt->fNShared/pt->GetNumberOfClusters()<0.7)) + if ((TMath::Abs(1/pt->GetC())<100.) && (pt->GetNShared()/pt->GetNumberOfClusters()<0.7)) isok =kTRUE; if (TMath::Abs(pt->GetZ()/pt->GetX())>1.1) isok =kTRUE; @@ -2406,10 +2535,10 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde isok =kTRUE; if (isok) - for (Int_t i=0; i<160; i++) { - Int_t index=pt->GetClusterIndex2(i); + for (Int_t j=0; j<160; ++j) { + Int_t index=pt->GetClusterIndex2(j); if (index<0) continue; - AliTPCclusterMI *c= pt->fClusterPointer[i]; + AliTPCclusterMI *c= pt->GetClusterPointer(j); if (!c) continue; //if (!(c->IsUsed(10))) c->Use(); c->Use(10); @@ -2426,12 +2555,12 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde continue; } //if (!(pt->IsActive())) continue; - if (pt->fBSigned) continue; + if (pt->GetBSigned()) continue; Double_t chi = pt->GetChi2()/pt->GetNumberOfClusters(); if (chi>maxchi) continue; Float_t bfactor=1; - Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->fNFoundable); + Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable()); //sign only tracks with enoug big density at the beginning @@ -2442,17 +2571,17 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde Double_t minn = TMath::Max(Int_t(meann-fnumber*smeann*bfactor),50); // if (pt->fBConstrain) mindens = TMath::Max(mdensity-sdensity*fdensity*bfactor,0.65); - if ( (pt->fRemoval==10) && (pt->GetSnp()>0.8)&&(dens>mindens)) + if ( (pt->GetRemoval()==10) && (pt->GetSnp()>0.8)&&(dens>mindens)) minn=0; if ((dens>mindens && pt->GetNumberOfClusters()>minn) && chiGetNumberOfClusters(); - pt->fBSigned = kTRUE; - for (Int_t i=0; i<160; i++) { + pt->SetBSigned(kTRUE); + for (Int_t j=0; j<160; ++j) { - Int_t index=pt->GetClusterIndex2(i); + Int_t index=pt->GetClusterIndex2(j); if (index<0) continue; - AliTPCclusterMI *c= pt->fClusterPointer[i]; + AliTPCclusterMI *c= pt->GetClusterPointer(j); if (!c) continue; // if (!(c->IsUsed(10))) c->Use(); c->Use(10); @@ -2467,7 +2596,7 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde } -void AliTPCtrackerMI::StopNotActive(TObjArray * arr, Int_t row0, Float_t th0, Float_t th1, Float_t th2) const +void AliTPCtrackerMI::StopNotActive(const TObjArray * arr, Int_t row0, Float_t th0, Float_t th1, Float_t th2) const { // stop not active tracks // take th1 as threshold for number of founded to number of foundable on last 10 active rows @@ -2495,8 +2624,8 @@ void AliTPCtrackerMI::StopNotActive(AliTPCseed * seed, Int_t row0, Float_t th0, Int_t sumgood1 = 0; Int_t sumgood2 = 0; Int_t foundable = 0; - Int_t maxindex = seed->fLastPoint; //last foundable row - if (seed->fNFoundable*th0 > seed->GetNumberOfClusters()) { + Int_t maxindex = seed->GetLastPoint(); //last foundable row + if (seed->GetNFoundable()*th0 > seed->GetNumberOfClusters()) { seed->Desactivate(10) ; return; } @@ -2521,17 +2650,28 @@ void AliTPCtrackerMI::StopNotActive(AliTPCseed * seed, Int_t row0, Float_t th0, } -Int_t AliTPCtrackerMI::RefitInward(AliESD *event) +Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event) { // // back propagation of ESD tracks // //return 0; + const Int_t kMaxFriendTracks=2000; fEvent = event; ReadSeeds(event,2); fIteration=2; //PrepareForProlongation(fSeeds,1); PropagateForward2(fSeeds); + RemoveUsed2(fSeeds,0.4,0.4,20); + + TObjArray arraySeed(fSeeds->GetEntries()); + for (Int_t i=0;iGetEntries();i++) { + arraySeed.AddAt(fSeeds->At(i),i); + } + SignShared(&arraySeed); + // FindCurling(fSeeds, event,2); // find multi found tracks + FindSplitted(fSeeds, event,2); // find multi found tracks + if (AliTPCReconstructor::StreamLevel()>5) FindMultiMC(fSeeds, fEvent,2); // find multi found tracks Int_t ntracks=0; Int_t nseed = fSeeds->GetEntriesFast(); @@ -2539,28 +2679,60 @@ Int_t AliTPCtrackerMI::RefitInward(AliESD *event) AliTPCseed * seed = (AliTPCseed*) fSeeds->UncheckedAt(i); if (!seed) continue; if (seed->GetKinkIndex(0)>0) UpdateKinkQualityD(seed); // update quality informations for kinks + AliESDtrack *esd=event->GetTrack(i); + + if (seed->GetNumberOfClusters()<60 && seed->GetNumberOfClusters()<(esd->GetTPCclusters(0) -5)*0.8){ + AliExternalTrackParam paramIn; + AliExternalTrackParam paramOut; + Int_t ncl = seed->RefitTrack(seed,¶mIn,¶mOut); + if (AliTPCReconstructor::StreamLevel()>2) { + (*fDebugStreamer)<<"RecoverIn"<< + "seed.="<15) { + seed->Set(paramIn.GetX(),paramIn.GetAlpha(),paramIn.GetParameter(),paramIn.GetCovariance()); + seed->SetNumberOfClusters(ncl); + } + } - seed->PropagateTo(fParam->GetInnerRadiusLow()); + seed->PropagateTo(fkParam->GetInnerRadiusLow()); seed->UpdatePoints(); - AliESDtrack *esd=event->GetTrack(i); + AddCovariance(seed); + MakeBitmaps(seed); seed->CookdEdx(0.02,0.6); CookLabel(seed,0.1); //For comparison only + esd->SetTPCClusterMap(seed->GetClusterMap()); + esd->SetTPCSharedMap(seed->GetSharedMap()); // - if (0 && seed!=0&&esd!=0) { + if (AliTPCReconstructor::StreamLevel()>1 && seed!=0&&esd!=0) { TTreeSRedirector &cstream = *fDebugStreamer; cstream<<"Crefit"<< "Esd.="<GetNumberOfClusters()>15){ esd->UpdateTrackParams(seed,AliESDtrack::kTPCrefit); esd->SetTPCPoints(seed->GetPoints()); - esd->SetTPCPointsF(seed->fNFoundable); - Int_t ndedx = seed->fNCDEDX[0]+seed->fNCDEDX[1]+seed->fNCDEDX[2]+seed->fNCDEDX[3]; - Float_t sdedx = (seed->fSDEDX[0]+seed->fSDEDX[1]+seed->fSDEDX[2]+seed->fSDEDX[3])*0.25; + esd->SetTPCPointsF(seed->GetNFoundable()); + Int_t ndedx = seed->GetNCDEDX(0); + Float_t sdedx = seed->GetSDEDX(0); Float_t dedx = seed->GetdEdx(); esd->SetTPCsignal(dedx, sdedx, ndedx); + // + // add seed to the esd track in Calib level + // + Bool_t storeFriend = gRandom->Rndm()<(kMaxFriendTracks)/Float_t(nseed); + if (AliTPCReconstructor::StreamLevel()>0 &&storeFriend){ + AliTPCseed * seedCopy = new AliTPCseed(*seed, kTRUE); + esd->AddCalibObject(seedCopy); + } ntracks++; } else{ @@ -2568,14 +2740,13 @@ Int_t AliTPCtrackerMI::RefitInward(AliESD *event) } } //FindKinks(fSeeds,event); + if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(2,fSeeds); Info("RefitInward","Number of refitted tracks %d",ntracks); - fEvent =0; - //WriteTracks(); return 0; } -Int_t AliTPCtrackerMI::PropagateBack(AliESD *event) +Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event) { // // back propagation of ESD tracks @@ -2586,6 +2757,10 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESD *event) ReadSeeds(event,1); PropagateBack(fSeeds); RemoveUsed2(fSeeds,0.4,0.4,20); + //FindCurling(fSeeds, fEvent,1); + FindSplitted(fSeeds, event,1); // find multi found tracks + if (AliTPCReconstructor::StreamLevel()>5) FindMultiMC(fSeeds, fEvent,1); // find multi found tracks + // Int_t nseed = fSeeds->GetEntriesFast(); Int_t ntracks=0; @@ -2594,24 +2769,53 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESD *event) if (!seed) continue; if (seed->GetKinkIndex(0)<0) UpdateKinkQualityM(seed); // update quality informations for kinks seed->UpdatePoints(); + AddCovariance(seed); AliESDtrack *esd=event->GetTrack(i); + if (seed->GetNumberOfClusters()<60 && seed->GetNumberOfClusters()<(esd->GetTPCclusters(0) -5)*0.8){ + AliExternalTrackParam paramIn; + AliExternalTrackParam paramOut; + Int_t ncl = seed->RefitTrack(seed,¶mIn,¶mOut); + if (AliTPCReconstructor::StreamLevel()>2) { + (*fDebugStreamer)<<"RecoverBack"<< + "seed.="<15) { + seed->Set(paramOut.GetX(),paramOut.GetAlpha(),paramOut.GetParameter(),paramOut.GetCovariance()); + seed->SetNumberOfClusters(ncl); + } + } seed->CookdEdx(0.02,0.6); CookLabel(seed,0.1); //For comparison only if (seed->GetNumberOfClusters()>15){ esd->UpdateTrackParams(seed,AliESDtrack::kTPCout); esd->SetTPCPoints(seed->GetPoints()); - esd->SetTPCPointsF(seed->fNFoundable); - Int_t ndedx = seed->fNCDEDX[0]+seed->fNCDEDX[1]+seed->fNCDEDX[2]+seed->fNCDEDX[3]; - Float_t sdedx = (seed->fSDEDX[0]+seed->fSDEDX[1]+seed->fSDEDX[2]+seed->fSDEDX[3])*0.25; + esd->SetTPCPointsF(seed->GetNFoundable()); + Int_t ndedx = seed->GetNCDEDX(0); + Float_t sdedx = seed->GetSDEDX(0); Float_t dedx = seed->GetdEdx(); esd->SetTPCsignal(dedx, sdedx, ndedx); ntracks++; + Int_t eventnumber = event->GetEventNumberInFile();// patch 28 fev 06 + // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number + if (AliTPCReconstructor::StreamLevel()>1 && esd) { + (*fDebugStreamer)<<"Cback"<< + "Tr0.="<3) DumpClusters(1,fSeeds); //FindKinks(fSeeds,event); Info("PropagateBack","Number of back propagated tracks %d",ntracks); fEvent =0; - //WriteTracks(); + return 0; } @@ -2620,16 +2824,18 @@ void AliTPCtrackerMI::DeleteSeeds() { // //delete Seeds + Int_t nseed = fSeeds->GetEntriesFast(); for (Int_t i=0;iAt(i); if (seed) delete fSeeds->RemoveAt(i); } delete fSeeds; + fSeeds =0; } -void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) +void AliTPCtrackerMI::ReadSeeds(AliESDEvent *const event, Int_t direction) { // //read seeds from the event @@ -2653,6 +2859,8 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) t.SetNumberOfClusters(0); // AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha()); AliTPCseed *seed = new AliTPCseed(t/*,t.GetAlpha()*/); + seed->SetUniqueID(esd->GetID()); + AddCovariance(seed); //add systematic ucertainty for (Int_t ikink=0;ikink<3;ikink++) { Int_t index = esd->GetKinkIndex(ikink); seed->GetKinkIndexes()[ikink] = index; @@ -2669,13 +2877,13 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) } } - if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(); - if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(); - if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) { - fSeeds->AddAt(0,i); - delete seed; - continue; - } + if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(10.); + if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.); + //if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) { + // fSeeds->AddAt(0,i); + // delete seed; + // continue; + //} if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) > 0 ) { Double_t par0[5],par1[5],alpha,x; esd->GetInnerExternalParameters(alpha,x,par0); @@ -2686,7 +2894,7 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) if (esd->GetTRDncls()>0) trdchi2 = esd->GetTRDchi2()/esd->GetTRDncls(); //reset covariance if suspicious if ( (delta1>0.1) || (delta2>0.006) ||trdchi2>7.) - seed->ResetCovariance(); + seed->ResetCovariance(10.); } // @@ -2706,7 +2914,7 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) delete seed; continue; } - seed->fEsd = esd; + seed->SetESD(esd); // sign clusters if (esd->GetKinkIndex(0)<=0){ for (Int_t irow=0;irow<160;irow++){ @@ -2714,7 +2922,7 @@ void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction) if (index>0){ // AliTPCclusterMI * cl = GetClusterMI(index); - seed->fClusterPointer[irow] = cl; + seed->SetClusterPointer(irow,cl); if (cl){ if ((index & 0x8000)==0){ cl->Use(10); // accepted cluster @@ -2754,7 +2962,7 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Double_t x[5], c[15]; // Int_t di = i1-i2; // - AliTPCseed * seed = new AliTPCseed; + AliTPCseed * seed = new AliTPCseed(); Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift(); Double_t cs=cos(alpha), sn=sin(alpha); // @@ -2768,13 +2976,13 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Int_t imiddle = (i2+i1)/2; //middle pad row index Double_t xm = GetXrow(imiddle); // radius of middle pad-row - const AliTPCRow& krm=GetRow(sec,imiddle); //middle pad -row + const AliTPCtrackerRow& krm=GetRow(sec,imiddle); //middle pad -row // Int_t ns =sec; - const AliTPCRow& kr1=GetRow(ns,i1); - Double_t ymax = GetMaxY(i1)-kr1.fDeadZone-1.5; - Double_t ymaxm = GetMaxY(imiddle)-kr1.fDeadZone-1.5; + const AliTPCtrackerRow& kr1=GetRow(ns,i1); + Double_t ymax = GetMaxY(i1)-kr1.GetDeadZone()-1.5; + Double_t ymaxm = GetMaxY(imiddle)-kr1.GetDeadZone()-1.5; // // change cut on curvature if it can't reach this layer @@ -2824,10 +3032,10 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, for (Int_t dsec = dsec1; dsec<=dsec2;dsec++){ Int_t sec2 = sec + dsec; // - // AliTPCRow& kr2 = fOuterSec[(sec2+fkNOS)%fkNOS][i2]; - //AliTPCRow& kr2m = fOuterSec[(sec2+fkNOS)%fkNOS][imiddle]; - AliTPCRow& kr2 = GetRow((sec2+fkNOS)%fkNOS,i2); - AliTPCRow& kr2m = GetRow((sec2+fkNOS)%fkNOS,imiddle); + // AliTPCtrackerRow& kr2 = fOuterSec[(sec2+fkNOS)%fkNOS][i2]; + //AliTPCtrackerRow& kr2m = fOuterSec[(sec2+fkNOS)%fkNOS][imiddle]; + AliTPCtrackerRow& kr2 = GetRow((sec2+fkNOS)%fkNOS,i2); + AliTPCtrackerRow& kr2m = GetRow((sec2+fkNOS)%fkNOS,imiddle); Int_t index1 = TMath::Max(kr2.Find(extraz-0.6-dddz1*TMath::Abs(z1)*0.05)-1,0); Int_t index2 = TMath::Min(kr2.Find(extraz+0.6+dddz2*TMath::Abs(z1)*0.05)+1,kr2); @@ -2964,12 +3172,13 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, // if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue; UInt_t index=kr1.GetIndex(is); - AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, ns*alpha+shift); + seed->~AliTPCseed(); // this does not set the pointer to 0... + AliTPCseed *track=new(seed) AliTPCseed(x1, ns*alpha+shift, x, c, index); - track->fIsSeeding = kTRUE; - track->fSeed1 = i1; - track->fSeed2 = i2; - track->fSeedType=3; + track->SetIsSeeding(kTRUE); + track->SetSeed1(i1); + track->SetSeed2(i2); + track->SetSeedType(3); //if (dsec==0) { @@ -2988,37 +3197,34 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, //Int_t rc = 1; - track->fBConstrain =1; + track->SetBConstrain(1); // track->fLastPoint = i1+fInnerSec->GetNRows(); // first cluster in track position - track->fLastPoint = i1; // first cluster in track position - track->fFirstPoint = track->fLastPoint; + track->SetLastPoint(i1); // first cluster in track position + track->SetFirstPoint(track->GetLastPoint()); if (track->GetNumberOfClusters()<(i1-i2)*0.5 || - track->GetNumberOfClusters() < track->fNFoundable*0.6 || - track->fNShared>0.4*track->GetNumberOfClusters() ) { + track->GetNumberOfClusters() < track->GetNFoundable()*0.6 || + track->GetNShared()>0.4*track->GetNumberOfClusters() ) { seed->Reset(); seed->~AliTPCseed(); continue; } nout1++; // Z VERTEX CONDITION - Double_t zv; - zv = track->GetZ()+track->GetTgl()/track->GetC()* - ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta())); + Double_t zv, bz=GetBz(); + if ( !track->GetZAt(0.,bz,zv) ) continue; if (TMath::Abs(zv-z3)>cuts[2]) { FollowProlongation(*track, TMath::Max(i2-20,0)); - zv = track->GetZ()+track->GetTgl()/track->GetC()* - ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta())); + if ( !track->GetZAt(0.,bz,zv) ) continue; if (TMath::Abs(zv-z3)>cuts[2]){ FollowProlongation(*track, TMath::Max(i2-40,0)); - zv = track->GetZ()+track->GetTgl()/track->GetC()* - ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta())); - if (TMath::Abs(zv-z3)>cuts[2] &&(track->GetNumberOfClusters() > track->fNFoundable*0.7)){ + if ( !track->GetZAt(0.,bz,zv) ) continue; + if (TMath::Abs(zv-z3)>cuts[2] &&(track->GetNumberOfClusters() > track->GetNFoundable()*0.7)){ // make seed without constrain AliTPCseed * track2 = MakeSeed(track,0.2,0.5,1.); FollowProlongation(*track2, i2,1); - track2->fBConstrain = kFALSE; - track2->fSeedType = 1; + track2->SetBConstrain(kFALSE); + track2->SetSeedType(1); arr->AddLast(track2); seed->Reset(); seed->~AliTPCseed(); @@ -3032,13 +3238,13 @@ void AliTPCtrackerMI::MakeSeeds3(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, } } } - - track->fSeedType =0; + + track->SetSeedType(0); arr->AddLast(track); seed = new AliTPCseed; nout2++; // don't consider other combinations - if (track->GetNumberOfClusters() > track->fNFoundable*0.8) + if (track->GetNumberOfClusters() > track->GetNFoundable()*0.8) break; } } @@ -3082,25 +3288,25 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, // first 3 padrows Double_t x1 = GetXrow(i1-1); - const AliTPCRow& kr1=GetRow(sec,i1-1); - Double_t y1max = GetMaxY(i1-1)-kr1.fDeadZone-1.5; + const AliTPCtrackerRow& kr1=GetRow(sec,i1-1); + Double_t y1max = GetMaxY(i1-1)-kr1.GetDeadZone()-1.5; // Double_t x1p = GetXrow(i1); - const AliTPCRow& kr1p=GetRow(sec,i1); + const AliTPCtrackerRow& kr1p=GetRow(sec,i1); // Double_t x1m = GetXrow(i1-2); - const AliTPCRow& kr1m=GetRow(sec,i1-2); + const AliTPCtrackerRow& kr1m=GetRow(sec,i1-2); // //last 3 padrow for seeding - AliTPCRow& kr3 = GetRow((sec+fkNOS)%fkNOS,i1-7); + AliTPCtrackerRow& kr3 = GetRow((sec+fkNOS)%fkNOS,i1-7); Double_t x3 = GetXrow(i1-7); // Double_t y3max= GetMaxY(i1-7)-kr3.fDeadZone-1.5; // - AliTPCRow& kr3p = GetRow((sec+fkNOS)%fkNOS,i1-6); + AliTPCtrackerRow& kr3p = GetRow((sec+fkNOS)%fkNOS,i1-6); Double_t x3p = GetXrow(i1-6); // - AliTPCRow& kr3m = GetRow((sec+fkNOS)%fkNOS,i1-8); + AliTPCtrackerRow& kr3m = GetRow((sec+fkNOS)%fkNOS,i1-8); Double_t x3m = GetXrow(i1-8); // @@ -3108,7 +3314,7 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, // middle padrow Int_t im = i1-4; //middle pad row index Double_t xm = GetXrow(im); // radius of middle pad-row - const AliTPCRow& krm=GetRow(sec,im); //middle pad -row + const AliTPCtrackerRow& krm=GetRow(sec,im); //middle pad -row // Double_t ymmax = GetMaxY(im)-kr1.fDeadZone-1.5; // // @@ -3254,15 +3460,16 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, // if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue; - UInt_t index=kr1.GetIndex(is); - AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, sec*alpha+shift); + index=kr1.GetIndex(is); + seed->~AliTPCseed(); + AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index); - track->fIsSeeding = kTRUE; + track->SetIsSeeding(kTRUE); nin++; FollowProlongation(*track, i1-7,1); - if (track->GetNumberOfClusters() < track->fNFoundable*0.75 || - track->fNShared>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){ + if (track->GetNumberOfClusters() < track->GetNFoundable()*0.75 || + track->GetNShared()>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){ seed->Reset(); seed->~AliTPCseed(); continue; @@ -3271,13 +3478,13 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, nout2++; //Int_t rc = 1; FollowProlongation(*track, i2,1); - track->fBConstrain =0; - track->fLastPoint = i1+fInnerSec->GetNRows(); // first cluster in track position - track->fFirstPoint = track->fLastPoint; + track->SetBConstrain(0); + track->SetLastPoint(i1+fInnerSec->GetNRows()); // first cluster in track position + track->SetFirstPoint(track->GetLastPoint()); if (track->GetNumberOfClusters()<(i1-i2)*0.5 || - track->GetNumberOfClusters()fNFoundable*0.7 || - track->fNShared>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) { + track->GetNumberOfClusters()GetNFoundable()*0.7 || + track->GetNShared()>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) { seed->Reset(); seed->~AliTPCseed(); continue; @@ -3287,8 +3494,8 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, FollowProlongation(*track, TMath::Max(i2-10,0),1); AliTPCseed * track2 = MakeSeed(track,0.2,0.5,0.9); FollowProlongation(*track2, i2,1); - track2->fBConstrain = kFALSE; - track2->fSeedType = 4; + track2->SetBConstrain(kFALSE); + track2->SetSeedType(4); arr->AddLast(track2); seed->Reset(); seed->~AliTPCseed(); @@ -3302,7 +3509,7 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, } if (fDebug>3){ - Info("MakeSeeds5","\nSeeding statiistic:\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2,nout3); + Info("MakeSeeds5","\nSeeding statiistic:\t%d\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2,nout3); } delete seed; } @@ -3331,8 +3538,8 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, // Double_t cs=cos(alpha), sn=sin(alpha); Int_t row0 = (i1+i2)/2; Int_t drow = (i1-i2)/2; - const AliTPCRow& kr0=fSectors[sec][row0]; - AliTPCRow * kr=0; + const AliTPCtrackerRow& kr0=fSectors[sec][row0]; + AliTPCtrackerRow * kr=0; AliTPCpolyTrack polytrack; Int_t nclusters=fSectors[sec][row0]; @@ -3345,8 +3552,8 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Int_t nfound =0; Int_t nfoundable =0; for (Int_t iter =1; iter<2; iter++){ //iterations - const AliTPCRow& krm=fSectors[sec][row0-iter]; - const AliTPCRow& krp=fSectors[sec][row0+iter]; + const AliTPCtrackerRow& krm=fSectors[sec][row0-iter]; + const AliTPCtrackerRow& krp=fSectors[sec][row0+iter]; const AliTPCclusterMI * cl= kr0[is]; if (cl->IsUsed(10)) { @@ -3366,7 +3573,7 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Float_t erry = 0; Float_t errz = 0; - Double_t ymax = fSectors->GetMaxY(row0)-kr0.fDeadZone-1.5; + Double_t ymax = fSectors->GetMaxY(row0)-kr0.GetDeadZone()-1.5; if (deltay>0 && TMath::Abs(ymax-TMath::Abs(y0))> deltay ) continue; // seed only at the edge erry = (0.5)*cl->GetSigmaY2()/TMath::Sqrt(cl->GetQ())*6; @@ -3415,9 +3622,9 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, Int_t row = row0+ddrow*delta; kr = &(fSectors[sec][row]); Double_t xn = kr->GetX(); - Double_t ymax = fSectors->GetMaxY(row)-kr->fDeadZone-1.5; + Double_t ymax1 = fSectors->GetMaxY(row)-kr->GetDeadZone()-1.5; polytrack.GetFitPoint(xn,yn,zn); - if (TMath::Abs(yn)>ymax) continue; + if (TMath::Abs(yn)>ymax1) continue; nfoundable++; AliTPCclusterMI * cln = kr->FindNearest(yn,zn,roady,roadz); if (cln) { @@ -3534,18 +3741,19 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, UInt_t index=0; //kr0.GetIndex(is); - AliTPCseed *track=new (seed) AliTPCseed(index, x, c, x1, sec*alpha+shift); - track->fIsSeeding = kTRUE; + seed->~AliTPCseed(); + AliTPCseed *track=new(seed) AliTPCseed(x1,sec*alpha+shift,x,c,index); + track->SetIsSeeding(kTRUE); Int_t rc=FollowProlongation(*track, i2); - if (constrain) track->fBConstrain =1; + if (constrain) track->SetBConstrain(1); else - track->fBConstrain =0; - track->fLastPoint = row1+fInnerSec->GetNRows(); // first cluster in track position - track->fFirstPoint = track->fLastPoint; + track->SetBConstrain(0); + track->SetLastPoint(row1+fInnerSec->GetNRows()); // first cluster in track position + track->SetFirstPoint(track->GetLastPoint()); if (rc==0 || track->GetNumberOfClusters()<(i1-i2)*0.5 || - track->GetNumberOfClusters() < track->fNFoundable*0.6 || - track->fNShared>0.4*track->GetNumberOfClusters()) { + track->GetNumberOfClusters() < track->GetNFoundable()*0.6 || + track->GetNShared()>0.4*track->GetNumberOfClusters()) { //delete track; seed->Reset(); seed->~AliTPCseed(); @@ -3565,7 +3773,7 @@ void AliTPCtrackerMI::MakeSeeds2(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, } -AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2) +AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *const track, Float_t r0, Float_t r1, Float_t r2) { // // @@ -3586,7 +3794,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, Int_t index=-1; Int_t clindex; for (Int_t i=0;i<160;i++){ - if (track->fClusterPointer[i]){ + if (track->GetClusterPointer(i)){ index++; AliTPCTrackerPoint *trpoint =track->GetTrackPoint(i); if ( (indexGetRowNumber(x2[0]); - AliTPCseed *seed=new AliTPCseed(0, x, c, x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift()); + AliTPCseed *seed=new AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0); // Double_t y0,z0,y1,z1, y2,z2; //seed->GetProlongation(x0[0],y0,z0); // seed->GetProlongation(x1[0],y1,z1); //seed->GetProlongation(x2[0],y2,z2); // seed =0; - seed->fLastPoint = pp2; - seed->fFirstPoint = pp2; + seed->SetLastPoint(pp2); + seed->SetFirstPoint(pp2); return seed; } -AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2) +AliTPCseed *AliTPCtrackerMI::ReSeed(const AliTPCseed *track, Float_t r0, Float_t r1, Float_t r2) { // // @@ -3803,9 +4011,9 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track, Float_t r0, Float_t r1, F c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43; // Int_t row1 = fSectors->GetRowNumber(xyz[2][0]); - AliTPCseed *seed=new AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift()); - seed->fLastPoint = row[2]; - seed->fFirstPoint = row[2]; + AliTPCseed *seed=new AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0); + seed->SetLastPoint(row[2]); + seed->SetFirstPoint(row[2]); return seed; } @@ -3952,17 +4160,557 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward) c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43; // Int_t row1 = fSectors->GetRowNumber(xyz[2][0]); - AliTPCseed *seed=new AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift()); - seed->fLastPoint = row[2]; - seed->fFirstPoint = row[2]; + AliTPCseed *seed=new AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0); + seed->SetLastPoint(row[2]); + seed->SetFirstPoint(row[2]); for (Int_t i=row[0];ifIndex[i] = track->fIndex[i]; + seed->SetClusterIndex(i, track->GetClusterIndex(i)); + } + + return seed; +} + + + +void AliTPCtrackerMI::FindMultiMC(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter) +{ + // + // find multi tracks - THIS FUNCTION IS ONLY FOR DEBUG PURPOSES + // USES MC LABELS + // Use AliTPCReconstructor::StreamLevel()>2 if you want to tune parameters - cuts + // + // Two reasons to have multiple find tracks + // 1. Curling tracks can be find more than once + // 2. Splitted tracks + // a.) Multiple seeding to increase tracking efficiency - (~ 100% reached) + // b.) Edge effect on the sector boundaries + // + // + // Algorithm done in 2 phases - because of CPU consumption + // it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated + // + // Algorihm for curling tracks sign: + // 1 phase -makes a very rough fast cuts to minimize combinatorics + // a.) opposite sign + // b.) one of the tracks - not pointing to the primary vertex - + // c.) delta tan(theta) + // d.) delta phi + // 2 phase - calculates DCA between tracks - time consument + + // + // fast cuts + // + // General cuts - for splitted tracks and for curling tracks + // + const Float_t kMaxdPhi = 0.2; // maximal distance in phi + // + // Curling tracks cuts + // + // + // + // + Int_t nentries = array->GetEntriesFast(); + AliHelix *helixes = new AliHelix[nentries]; + Float_t *xm = new Float_t[nentries]; + Float_t *dz0 = new Float_t[nentries]; + Float_t *dz1 = new Float_t[nentries]; + // + // + TStopwatch timer; + timer.Start(); + // + // Find track COG in x direction - point with best defined parameters + // + for (Int_t i=0;iAt(i); + if (!track) continue; + track->SetCircular(0); + new (&helixes[i]) AliHelix(*track); + Int_t ncl=0; + xm[i]=0; + Float_t dz[2]; + track->GetDZ(GetX(),GetY(),GetZ(),GetBz(),dz); + dz0[i]=dz[0]; + dz1[i]=dz[1]; + for (Int_t icl=0; icl<160; icl++){ + AliTPCclusterMI * cl = track->GetClusterPointer(icl); + if (cl) { + xm[i]+=cl->GetX(); + ncl++; + } + } + if (ncl>0) xm[i]/=Float_t(ncl); + } + // + for (Int_t i0=0;i0At(i0); + if (!track0) continue; + Float_t xc0 = helixes[i0].GetHelix(6); + Float_t yc0 = helixes[i0].GetHelix(7); + Float_t r0 = helixes[i0].GetHelix(8); + Float_t rc0 = TMath::Sqrt(xc0*xc0+yc0*yc0); + Float_t fi0 = TMath::ATan2(yc0,xc0); + + for (Int_t i1=i0+1;i1At(i1); + if (!track1) continue; + Int_t lab0=track0->GetLabel(); + Int_t lab1=track1->GetLabel(); + if (TMath::Abs(lab0)!=TMath::Abs(lab1)) continue; + // + Float_t xc1 = helixes[i1].GetHelix(6); + Float_t yc1 = helixes[i1].GetHelix(7); + Float_t r1 = helixes[i1].GetHelix(8); + Float_t rc1 = TMath::Sqrt(xc1*xc1+yc1*yc1); + Float_t fi1 = TMath::ATan2(yc1,xc1); + // + Float_t dfi = fi0-fi1; + // + // + if (dfi>1.5*TMath::Pi()) dfi-=TMath::Pi(); // take care about edge effect + if (dfi<-1.5*TMath::Pi()) dfi+=TMath::Pi(); // + if (TMath::Abs(dfi)>kMaxdPhi&&helixes[i0].GetHelix(4)*helixes[i1].GetHelix(4)<0){ + // + // if short tracks with undefined sign + fi1 = -TMath::ATan2(yc1,-xc1); + dfi = fi0-fi1; + } + Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl(); + + // + // debug stream to tune "fast cuts" + // + Double_t dist[3]; // distance at X + Double_t mdist[3]={0,0,0}; // mean distance X+-40cm + track0->GetDistance(track1,0.5*(xm[i0]+xm[i1])-40.,dist,AliTracker::GetBz()); + for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]); + track0->GetDistance(track1,0.5*(xm[i0]+xm[i1])+40.,dist,AliTracker::GetBz()); + for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]); + track0->GetDistance(track1,0.5*(xm[i0]+xm[i1]),dist,AliTracker::GetBz()); + for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[i]); + for (Int_t i=0;i<3;i++) mdist[i]*=0.33333; + + Float_t sum =0; + Float_t sums=0; + for (Int_t icl=0; icl<160; icl++){ + AliTPCclusterMI * cl0 = track0->GetClusterPointer(icl); + AliTPCclusterMI * cl1 = track1->GetClusterPointer(icl); + if (cl0&&cl1) { + sum++; + if (cl0==cl1) sums++; + } + } + // + if (AliTPCReconstructor::StreamLevel()>5) { + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"Multi"<< + "iter="<1) { + AliInfo("Time for curling tracks removal DEBUGGING MC"); + timer.Print(); + } +} + + + +void AliTPCtrackerMI::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int_t /*iter*/){ + // + // Find Splitted tracks and remove the one with worst quality + // Corresponding debug streamer to tune selections - "Splitted2" + // Algorithm: + // 0. Sort tracks according quility + // 1. Propagate the tracks to the reference radius + // 2. Double_t loop to select close tracks (only to speed up process) + // 3. Calculate cluster overlap ratio - and remove the track if bigger than a threshold + // 4. Delete temporary parameters + // + const Double_t xref=GetXrow(63); // reference radius -IROC/OROC boundary + // rough cuts + const Double_t kCutP1=10; // delta Z cut 10 cm + const Double_t kCutP2=0.15; // delta snp(fi) cut 0.15 + const Double_t kCutP3=0.15; // delta tgl(theta) cut 0.15 + const Double_t kCutAlpha=0.15; // delta alpha cut + Int_t firstpoint = 0; + Int_t lastpoint = 160; + // + Int_t nentries = array->GetEntriesFast(); + AliExternalTrackParam *params = new AliExternalTrackParam[nentries]; + // + // + TStopwatch timer; + timer.Start(); + // + //0. Sort tracks according quality + //1. Propagate the ext. param to reference radius + Int_t nseed = array->GetEntriesFast(); + if (nseed<=0) return; + Float_t * quality = new Float_t[nseed]; + Int_t * indexes = new Int_t[nseed]; + for (Int_t i=0; iUncheckedAt(i); + if (!pt){ + quality[i]=-1; + continue; + } + pt->UpdatePoints(); //select first last max dens points + Float_t * points = pt->GetPoints(); + if (points[3]<0.8) quality[i] =-1; + quality[i] = (points[2]-points[0])+pt->GetNumberOfClusters(); + //prefer high momenta tracks if overlaps + quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5); + params[i]=(*pt); + AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),5.,kTRUE); + AliTracker::PropagateTrackToBxByBz(&(params[i]),xref,pt->GetMass(),1.,kTRUE); + } + TMath::Sort(nseed,quality,indexes); + // + // 3. Loop over pair of tracks + // + for (Int_t i0=0; i0UncheckedAt(index0))) continue; + AliTPCseed *s1 = (AliTPCseed*)array->UncheckedAt(index0); + if (!s1->IsActive()) continue; + AliExternalTrackParam &par0=params[index0]; + for (Int_t i1=i0+1; i1UncheckedAt(index1))) continue; + AliTPCseed *s2 = (AliTPCseed*)array->UncheckedAt(index1); + if (!s2->IsActive()) continue; + if (s2->GetKinkIndexes()[0]!=0) + if (s2->GetKinkIndexes()[0] == -s1->GetKinkIndexes()[0]) continue; + AliExternalTrackParam &par1=params[index1]; + if (TMath::Abs(par0.GetParameter()[3]-par1.GetParameter()[3])>kCutP3) continue; + if (TMath::Abs(par0.GetParameter()[1]-par1.GetParameter()[1])>kCutP1) continue; + if (TMath::Abs(par0.GetParameter()[2]-par1.GetParameter()[2])>kCutP2) continue; + Double_t dAlpha= TMath::Abs(par0.GetAlpha()-par1.GetAlpha()); + if (dAlpha>TMath::Pi()) dAlpha-=TMath::Pi(); + if (TMath::Abs(dAlpha)>kCutAlpha) continue; + // + Int_t sumShared=0; + Int_t nall0=0; + Int_t nall1=0; + Int_t firstShared=lastpoint, lastShared=firstpoint; + Int_t firstRow=lastpoint, lastRow=firstpoint; + // + for (Int_t i=firstpoint;iGetClusterIndex2(i)>0) nall0++; + if (s2->GetClusterIndex2(i)>0) nall1++; + if (s1->GetClusterIndex2(i)>0 && s2->GetClusterIndex2(i)>0) { + if (ilastRow) lastRow=i; + } + if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) { + if (ilastShared) lastShared=i; + sumShared++; + } + } + Double_t ratio0 = Float_t(sumShared)/Float_t(TMath::Min(nall0+1,nall1+1)); + Double_t ratio1 = Float_t(sumShared)/Float_t(TMath::Max(nall0+1,nall1+1)); + + if( AliTPCReconstructor::StreamLevel()>1){ + TTreeSRedirector &cstream = *fDebugStreamer; + Int_t n0=s1->GetNumberOfClusters(); + Int_t n1=s2->GetNumberOfClusters(); + Int_t n0F=s1->GetNFoundable(); + Int_t n1F=s2->GetNFoundable(); + Int_t lab0=s1->GetLabel(); + Int_t lab1=s2->GetLabel(); + + cstream<<"Splitted2"<< + "iter="<AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(0) || + ratio1>AliTPCReconstructor::GetRecoParam()->GetCutSharedClusters(1)){ + // + // + // + delete array->RemoveAt(index1); + } + } + } + // + // 4. Delete temporary array + // + delete [] params; + delete [] quality; + delete [] indexes; + +} + + + +void AliTPCtrackerMI::FindCurling(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter) +{ + // + // find Curling tracks + // Use AliTPCReconstructor::StreamLevel()>1 if you want to tune parameters - cuts + // + // + // Algorithm done in 2 phases - because of CPU consumption + // it is n^2 algorithm - for lead-lead 20000x20000 combination are investigated + // see detal in MC part what can be used to cut + // + // + // + const Float_t kMaxC = 400; // maximal curvature to of the track + const Float_t kMaxdTheta = 0.15; // maximal distance in theta + const Float_t kMaxdPhi = 0.15; // maximal distance in phi + const Float_t kPtRatio = 0.3; // ratio between pt + const Float_t kMinDCAR = 2.; // distance to the primary vertex in r - see cpipe cut + + // + // Curling tracks cuts + // + // + const Float_t kMaxDeltaRMax = 40; // distance in outer radius + const Float_t kMaxDeltaRMin = 5.; // distance in lower radius - see cpipe cut + const Float_t kMinAngle = 2.9; // angle between tracks + const Float_t kMaxDist = 5; // biggest distance + // + // The cuts can be tuned using the "MC information stored in Multi tree ==> see FindMultiMC + /* + Fast cuts: + TCut csign("csign","Tr0.fP[4]*Tr1.fP[4]<0"); //opposite sign + TCut cmax("cmax","abs(Tr0.GetC())>1/400"); + TCut cda("cda","sqrt(dtheta^2+dfi^2)<0.15"); + TCut ccratio("ccratio","abs((Tr0.fP[4]+Tr1.fP[4])/(abs(Tr0.fP[4])+abs(Tr1.fP[4])))<0.3"); + TCut cpipe("cpipe", "min(abs(r0-rc0),abs(r1-rc1))>5"); + // + TCut cdrmax("cdrmax","abs(abs(rc0+r0)-abs(rc1+r1))<40") + TCut cdrmin("cdrmin","abs(abs(rc0+r0)-abs(rc1+r1))<10") + // + Multi->Draw("dfi","iter==0"+csign+cmax+cda+ccratio); ~94% of curling tracks fulfill + Multi->Draw("min(abs(r0-rc0),abs(r1-rc1))","iter==0&&abs(lab1)==abs(lab0)"+csign+cmax+cda+ccratio+cpipe+cdrmin+cdrmax); //80% + // + Curling2->Draw("dfi","iter==0&&abs(lab0)==abs(lab1)"+csign+cmax+cdtheta+cdfi+ccratio) + + */ + // + // + // + Int_t nentries = array->GetEntriesFast(); + AliHelix *helixes = new AliHelix[nentries]; + for (Int_t i=0;iAt(i); + if (!track) continue; + track->SetCircular(0); + new (&helixes[i]) AliHelix(*track); } + // + // + TStopwatch timer; + timer.Start(); + Double_t phase[2][2],radius[2]; + // + // Find tracks + // + // + for (Int_t i0=0;i0At(i0); + if (!track0) continue; + if (TMath::Abs(track0->GetC())<1/kMaxC) continue; + Float_t xc0 = helixes[i0].GetHelix(6); + Float_t yc0 = helixes[i0].GetHelix(7); + Float_t r0 = helixes[i0].GetHelix(8); + Float_t rc0 = TMath::Sqrt(xc0*xc0+yc0*yc0); + Float_t fi0 = TMath::ATan2(yc0,xc0); + + for (Int_t i1=i0+1;i1At(i1); + if (!track1) continue; + if (TMath::Abs(track1->GetC())<1/kMaxC) continue; + Float_t xc1 = helixes[i1].GetHelix(6); + Float_t yc1 = helixes[i1].GetHelix(7); + Float_t r1 = helixes[i1].GetHelix(8); + Float_t rc1 = TMath::Sqrt(xc1*xc1+yc1*yc1); + Float_t fi1 = TMath::ATan2(yc1,xc1); + // + Float_t dfi = fi0-fi1; + // + // + if (dfi>1.5*TMath::Pi()) dfi-=TMath::Pi(); // take care about edge effect + if (dfi<-1.5*TMath::Pi()) dfi+=TMath::Pi(); // + Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl(); + // + // + // FIRST fast cuts + if (track0->GetBConstrain()&&track1->GetBConstrain()) continue; // not constrained + if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0) continue; // not the same sign + if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>kMaxdTheta) continue; //distance in the Theta + if ( TMath::Abs(dfi)>kMaxdPhi) continue; //distance in phi + if ( TMath::Sqrt(dfi*dfi+dtheta*dtheta)>kMaxdPhi) continue; //common angular offset + // + Float_t pt0 = track0->GetSignedPt(); + Float_t pt1 = track1->GetSignedPt(); + if ((TMath::Abs(pt0+pt1)/(TMath::Abs(pt0)+TMath::Abs(pt1)))>kPtRatio) continue; + if ((iter==1) && TMath::Abs(TMath::Abs(rc0+r0)-TMath::Abs(rc1+r1))>kMaxDeltaRMax) continue; + if ((iter!=1) &&TMath::Abs(TMath::Abs(rc0-r0)-TMath::Abs(rc1-r1))>kMaxDeltaRMin) continue; + if (TMath::Min(TMath::Abs(rc0-r0),TMath::Abs(rc1-r1))0){ + Int_t ibest=0; + helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2); + if (npoints==2){ + helixes[i0].ParabolicDCA(helixes[i1],phase[1][0],phase[1][1],radius[1],deltah[1],2); + if (deltah[1]kMaxDist) continue; + // if (mindcar+mindcaz<40 && (TMath::Abs(hangles[2])3)) continue; + Bool_t sign =kFALSE; + if (hangles[2]>kMinAngle) sign =kTRUE; + // + if (sign){ + // circular[i0] = kTRUE; + // circular[i1] = kTRUE; + if (track0->OneOverPt()OneOverPt()){ + track0->SetCircular(track0->GetCircular()+1); + track1->SetCircular(track1->GetCircular()+2); + } + else{ + track1->SetCircular(track1->GetCircular()+1); + track0->SetCircular(track0->GetCircular()+2); + } + } + if (AliTPCReconstructor::StreamLevel()>2){ + // + //debug stream to tune "fine" cuts + Int_t lab0=track0->GetLabel(); + Int_t lab1=track1->GetLabel(); + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"Curling2"<< + "iter="<1) { + AliInfo("Time for curling tracks removal"); + timer.Print(); + } } -void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) + + + + +void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) { // // find kinks @@ -3976,7 +4724,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) Int_t *sign = new Int_t[nentries]; Int_t *nclusters = new Int_t[nentries]; Float_t *alpha = new Float_t[nentries]; - AliESDkink * kink = new AliESDkink(); + AliKink *kink = new AliKink(); Int_t * usage = new Int_t[nentries]; Float_t *zm = new Float_t[nentries]; Float_t *z0 = new Float_t[nentries]; @@ -3996,7 +4744,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) usage[i]=0; AliTPCseed* track = (AliTPCseed*)array->At(i); if (!track) continue; - track->fCircular =0; + track->SetCircular(0); shared[i] = kFALSE; track->UpdatePoints(); if (( track->GetPoints()[2]- track->GetPoints()[0])>5 && track->GetPoints()[3]>0.8){ @@ -4033,25 +4781,24 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) // // Find circling track - TTreeSRedirector &cstream = *fDebugStreamer; // for (Int_t i0=0;i0At(i0); if (!track0) continue; - if (track0->fN<40) continue; - if (TMath::Abs(1./track0->fP4)>200) continue; + if (track0->GetNumberOfClusters()<40) continue; + if (TMath::Abs(1./track0->GetC())>200) continue; for (Int_t i1=i0+1;i1At(i1); if (!track1) continue; - if (track1->fN<40) continue; - if ( TMath::Abs(track1->fP3+track0->fP3)>0.1) continue; - if (track0->fBConstrain&&track1->fBConstrain) continue; - if (TMath::Abs(1./track1->fP4)>200) continue; - if (track1->fP4*track0->fP4>0) continue; - if (track1->fP3*track0->fP3>0) continue; - if (max(TMath::Abs(1./track0->fP4),TMath::Abs(1./track1->fP4))>190) continue; - if (track0->fBConstrain&&TMath::Abs(track1->fP4)fP4)) continue; //returning - lower momenta - if (track1->fBConstrain&&TMath::Abs(track0->fP4)fP4)) continue; //returning - lower momenta + if (track1->GetNumberOfClusters()<40) continue; + if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue; + if (track0->GetBConstrain()&&track1->GetBConstrain()) continue; + if (TMath::Abs(1./track1->GetC())>200) continue; + if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0) continue; + if (track1->GetTgl()*track0->GetTgl()>0) continue; + if (TMath::Max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue; + if (track0->GetBConstrain()&&track1->OneOverPt()OneOverPt()) continue; //returning - lower momenta + if (track1->GetBConstrain()&&track0->OneOverPt()OneOverPt()) continue; //returning - lower momenta // Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1])); if (mindcar<5) continue; @@ -4086,14 +4833,6 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) helixes[i0].GetAngle(phase[0][0],helixes[i1],phase[0][1],hangles); Double_t deltah[2],deltabest; if (hangles[2]<2.8) continue; - /* - cstream<<"C"<fLab<fLab<< - track0->fP3<fP3<< - track0->fP4<fP4<< - delta<0){ Int_t ibest=0; helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2); @@ -4109,26 +4848,29 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) // if (deltabest>6) continue; if (mindcar+mindcaz<40 && (hangles[2]<3.12||deltabest>3)) continue; - Bool_t sign =kFALSE; - if (hangles[2]>3.06) sign =kTRUE; + Bool_t lsign =kFALSE; + if (hangles[2]>3.06) lsign =kTRUE; // - if (sign){ + if (lsign){ circular[i0] = kTRUE; circular[i1] = kTRUE; - if (TMath::Abs(track0->fP4)fP4)){ - track0->fCircular += 1; - track1->fCircular += 2; + if (track0->OneOverPt()OneOverPt()){ + track0->SetCircular(track0->GetCircular()+1); + track1->SetCircular(track1->GetCircular()+2); } else{ - track1->fCircular += 1; - track0->fCircular += 2; + track1->SetCircular(track1->GetCircular()+1); + track0->SetCircular(track0->GetCircular()+2); } } - if (sign&&0){ - //debug stream + if (lsign&&AliTPCReconstructor::StreamLevel()>1){ + //debug stream + Int_t lab0=track0->GetLabel(); + Int_t lab1=track1->GetLabel(); + TTreeSRedirector &cstream = *fDebugStreamer; cstream<<"Curling"<< - "lab0="<fLab<< - "lab1="<fLab<< + "lab0="<GetClusterStatistic(0,row0-5, found, foundable,shared,kFALSE); + Int_t found,foundable,ishared; + track0->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE); if (foundable>5) dens00 = Float_t(found)/Float_t(foundable); - track0->GetClusterStatistic(row0+5,155, found, foundable,shared,kFALSE); + track0->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE); if (foundable>5) dens01 = Float_t(found)/Float_t(foundable); // - track1->GetClusterStatistic(0,row0-5, found, foundable,shared,kFALSE); + track1->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE); if (foundable>10) dens10 = Float_t(found)/Float_t(foundable); - track1->GetClusterStatistic(row0+5,155, found, foundable,shared,kFALSE); + track1->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE); if (foundable>10) dens11 = Float_t(found)/Float_t(foundable); // if (dens00GetC())>5) continue; // cut on the curvature for mother particle AliExternalTrackParam paramm(*ktrack0); AliExternalTrackParam paramd(*ktrack1); - if (row0>60&&ktrack1->GetReference().GetX()>90.) new (¶md) AliExternalTrackParam(ktrack1->GetReference()); + if (row0>60&&ktrack1->GetReference().GetX()>90.)new (¶md) AliExternalTrackParam(ktrack1->GetReference()); // // kink->SetMother(paramm); @@ -4272,8 +5018,8 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) Float_t x[3] = { kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]}; Int_t index[4]; - fParam->Transform0to1(x,index); - fParam->Transform1to2(x,index); + fkParam->Transform0to1(x,index); + fkParam->Transform1to2(x,index); row0 = GetRowNumber(x[0]); if (kink->GetR()<100) continue; @@ -4290,7 +5036,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) if (mpt<1){ //for high momenta momentum not defined well in first iteration - Double_t qt = TMath::Sin(kink->GetAngle(2))*ktrack1->P(); + Double_t qt = TMath::Sin(kink->GetAngle(2))*ktrack1->GetP(); if (qt>0.35) continue; } @@ -4317,12 +5063,12 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) // angle and densities not defined yet if (kink->GetTPCDensityFactor()<0.8) continue; if ((2-kink->GetTPCDensityFactor())*kink->GetDistance() >0.25) continue; - if (kink->GetAngle(2)*ktrack0->P()<0.003) continue; //too small angle + if (kink->GetAngle(2)*ktrack0->GetP()<0.003) continue; //too small angle if (kink->GetAngle(2)>0.2&&kink->GetTPCDensityFactor()<1.15) continue; if (kink->GetAngle(2)>0.2&&kink->GetTPCDensity(0,1)>0.05) continue; - Float_t criticalangle = track0->fC22+track0->fC33; - criticalangle+= track1->fC22+track1->fC33; + Float_t criticalangle = track0->GetSigmaSnp2()+track0->GetSigmaTgl2(); + criticalangle+= track1->GetSigmaSnp2()+track1->GetSigmaTgl2(); criticalangle= 3*TMath::Sqrt(criticalangle); if (criticalangle>0.02) criticalangle=0.02; if (kink->GetAngle(2)155) continue; - if (ktrack0->fClusterPointer[row]){ + if (ktrack0->GetClusterPointer(row)){ AliTPCTrackerPoint *point =ktrack0->GetTrackPoint(row); shapesum+=point->GetSigmaY()+point->GetSigmaZ(); sum++; } - if (ktrack1->fClusterPointer[row]){ + if (ktrack1->GetClusterPointer(row)){ AliTPCTrackerPoint *point =ktrack1->GetTrackPoint(row); shapesum+=point->GetSigmaY()+point->GetSigmaZ(); sum++; @@ -4352,8 +5098,32 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) kink->SetShapeFactor(shapesum/sum); } // esd->AddKink(kink); + // + // kink->SetMother(paramm); + //kink->SetDaughter(paramd); + + Double_t chi2P2 = paramm.GetParameter()[2]-paramd.GetParameter()[2]; + chi2P2*=chi2P2; + chi2P2/=paramm.GetCovariance()[5]+paramd.GetCovariance()[5]; + Double_t chi2P3 = paramm.GetParameter()[3]-paramd.GetParameter()[3]; + chi2P3*=chi2P3; + chi2P3/=paramm.GetCovariance()[9]+paramd.GetCovariance()[9]; + // + if (AliTPCReconstructor::StreamLevel()>1) { + (*fDebugStreamer)<<"kinkLpt"<< + "chi2P2="<GetKinkAngleCutChi2(0)){ + continue; + } + // kinks->AddLast(kink); - kink = new AliESDkink; + kink = new AliKink; ncandidates++; } } @@ -4369,43 +5139,43 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) // for (Int_t i=0;iAt(i); + AliKink *kinkl = (AliKink*)kinks->At(i); // // refit kinks towards vertex // - Int_t index0 = kink->GetIndex(0); - Int_t index1 = kink->GetIndex(1); + Int_t index0 = kinkl->GetIndex(0); + Int_t index1 = kinkl->GetIndex(1); AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0); AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1); // - Int_t sumn=ktrack0->fN+ktrack1->fN; + Int_t sumn=ktrack0->GetNumberOfClusters()+ktrack1->GetNumberOfClusters(); // // Refit Kink under if too small angle // - if (kink->GetAngle(2)<0.05){ - kink->SetTPCRow0(GetRowNumber(kink->GetR())); - Int_t row0 = kink->GetTPCRow0(); - Int_t drow = Int_t(2.+0.5/(0.05+kink->GetAngle(2))); + if (kinkl->GetAngle(2)<0.05){ + kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR())); + Int_t row0 = kinkl->GetTPCRow0(); + Int_t drow = Int_t(2.+0.5/(0.05+kinkl->GetAngle(2))); // // Int_t last = row0-drow; if (last<40) last=40; - if (lastfFirstPoint+25) last = ktrack0->fFirstPoint+25; + if (lastGetFirstPoint()+25) last = ktrack0->GetFirstPoint()+25; AliTPCseed* seed0 = ReSeed(ktrack0,last,kFALSE); // // Int_t first = row0+drow; if (first>130) first=130; - if (first>ktrack1->fLastPoint-25) first = TMath::Max(ktrack1->fLastPoint-25,30); + if (first>ktrack1->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30); AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE); // if (seed0 && seed1){ - kink->SetStatus(1,8); - if (RefitKink(*seed0,*seed1,*kink)) kink->SetStatus(1,9); - row0 = GetRowNumber(kink->GetR()); - sumn = seed0->fN+seed1->fN; - new (&mothers[i]) AliTPCseed(*seed0); - new (&daughters[i]) AliTPCseed(*seed1); + kinkl->SetStatus(1,8); + if (RefitKink(*seed0,*seed1,*kinkl)) kinkl->SetStatus(1,9); + row0 = GetRowNumber(kinkl->GetR()); + sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters(); + mothers[i] = *seed0; + daughters[i] = *seed1; } else{ delete kinks->RemoveAt(i); @@ -4413,7 +5183,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) if (seed1) delete seed1; continue; } - if (kink->GetDistance()>0.5 || kink->GetR()<110 || kink->GetR()>240) { + if (kinkl->GetDistance()>0.5 || kinkl->GetR()<110 || kinkl->GetR()>240) { delete kinks->RemoveAt(i); if (seed0) delete seed0; if (seed1) delete seed1; @@ -4424,19 +5194,19 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) delete seed1; } // - if (kink) quality[i] = 160*((0.1+kink->GetDistance())*(2.-kink->GetTPCDensityFactor()))/(sumn+40.); //the longest -clossest will win + if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.); //the longest -clossest will win } TMath::Sort(nkinks,quality,indexes,kFALSE); // //remove double find kinks // for (Int_t ikink0=1;ikink0At(indexes[ikink0]); + AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]); if (!kink0) continue; // for (Int_t ikink1=0;ikink1At(indexes[ikink1]); + AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]); if (!kink1) continue; // if not close kink continue if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue; @@ -4457,10 +5227,10 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) Int_t bothd = 0; // for (Int_t i=0;i0 && mother1.fIndex[i]>0){ + if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){ both++; bothm++; - if (mother0.fIndex[i]==mother1.fIndex[i]){ + if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){ same++; samem++; } @@ -4468,10 +5238,10 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) } for (Int_t i=row0;i<158;i++){ - if (daughter0.fIndex[i]>0 && daughter0.fIndex[i]>0){ + if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){ both++; bothd++; - if (mother0.fIndex[i]==mother1.fIndex[i]){ + if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){ same++; samed++; } @@ -4481,8 +5251,8 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) Float_t ratiom = Float_t(samem+1)/Float_t(bothm+1); Float_t ratiod = Float_t(samed+1)/Float_t(bothd+1); if (ratio>0.3 && ratiom>0.5 &&ratiod>0.5) { - Int_t sum0 = mother0.fN+daughter0.fN; - Int_t sum1 = mother1.fN+daughter1.fN; + Int_t sum0 = mother0.GetNumberOfClusters()+daughter0.GetNumberOfClusters(); + Int_t sum1 = mother1.GetNumberOfClusters()+daughter1.GetNumberOfClusters(); if (sum1>sum0){ shared[kink0->GetIndex(0)]= kTRUE; shared[kink0->GetIndex(1)]= kTRUE; @@ -4499,34 +5269,34 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) for (Int_t i=0;iAt(indexes[i]); - if (!kink) continue; - kink->SetTPCRow0(GetRowNumber(kink->GetR())); - Int_t index0 = kink->GetIndex(0); - Int_t index1 = kink->GetIndex(1); - if (circular[index0]||circular[index1]&&kink->GetDistance()>0.2) continue; - kink->SetMultiple(usage[index0],0); - kink->SetMultiple(usage[index1],1); - if (kink->GetMultiple()[0]+kink->GetMultiple()[1]>2) continue; - if (kink->GetMultiple()[0]+kink->GetMultiple()[1]>0 && quality[indexes[i]]>0.2) continue; - if (kink->GetMultiple()[0]+kink->GetMultiple()[1]>0 && kink->GetDistance()>0.2) continue; - if (circular[index0]||circular[index1]&&kink->GetDistance()>0.1) continue; + AliKink * kinkl = (AliKink*) kinks->At(indexes[i]); + if (!kinkl) continue; + kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR())); + Int_t index0 = kinkl->GetIndex(0); + Int_t index1 = kinkl->GetIndex(1); + if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.2)) continue; + kinkl->SetMultiple(usage[index0],0); + kinkl->SetMultiple(usage[index1],1); + if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>2) continue; + if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && quality[indexes[i]]>0.2) continue; + if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && kinkl->GetDistance()>0.2) continue; + if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.1)) continue; AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0); AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1); if (!ktrack0 || !ktrack1) continue; - Int_t index = esd->AddKink(kink); + Int_t index = esd->AddKink(kinkl); // // - if ( ktrack0->fKinkIndexes[0]==0 && ktrack1->fKinkIndexes[0]==0) { //best kink - if (mothers[indexes[i]].fN>20 && daughters[indexes[i]].fN>20 && (mothers[indexes[i]].fN+daughters[indexes[i]].fN)>100){ - new (ktrack0) AliTPCseed(mothers[indexes[i]]); - new (ktrack1) AliTPCseed(daughters[indexes[i]]); + if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink + if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){ + *ktrack0 = mothers[indexes[i]]; + *ktrack1 = daughters[indexes[i]]; } } // - ktrack0->fKinkIndexes[usage[index0]] = -(index+1); - ktrack1->fKinkIndexes[usage[index1]] = (index+1); + ktrack0->SetKinkIndex(usage[index0],-(index+1)); + ktrack1->SetKinkIndex(usage[index1], (index+1)); usage[index0]++; usage[index1]++; } @@ -4536,7 +5306,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) for (Int_t i=0;iAt(i); if (!track0) continue; - if (track0->fKinkIndexes[0]!=0) continue; + if (track0->GetKinkIndex(0)!=0) continue; if (shared[i]) delete array->RemoveAt(i); } @@ -4556,30 +5326,31 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) if (!track0) continue; if (track0->Pt()<1.4) continue; //remove double high momenta tracks - overlapped with kink candidates - Int_t shared=0; + Int_t ishared=0; Int_t all =0; - for (Int_t icl=track0->fFirstPoint;iclfLastPoint; icl++){ - if (track0->fClusterPointer[icl]!=0){ + for (Int_t icl=track0->GetFirstPoint();iclGetLastPoint(); icl++){ + if (track0->GetClusterPointer(icl)!=0){ all++; - if (track0->fClusterPointer[icl]->IsUsed(10)) shared++; + if (track0->GetClusterPointer(icl)->IsUsed(10)) ishared++; } } - if (Float_t(shared+1)/Float_t(nall+1)>0.5) { + if (Float_t(ishared+1)/Float_t(all+1)>0.5) { delete array->RemoveAt(i); + continue; } // - if (track0->fKinkIndexes[0]!=0) continue; + if (track0->GetKinkIndex(0)!=0) continue; if (track0->GetNumberOfClusters()<80) continue; AliTPCseed *pmother = new AliTPCseed(); AliTPCseed *pdaughter = new AliTPCseed(); - AliESDkink *pkink = new AliESDkink; + AliKink *pkink = new AliKink; AliTPCseed & mother = *pmother; AliTPCseed & daughter = *pdaughter; - AliESDkink & kink = *pkink; - if (CheckKinkPoint(track0,mother,daughter, kink)){ - if (mother.fN<30||daughter.fN<20) { + AliKink & kinkl = *pkink; + if (CheckKinkPoint(track0,mother,daughter, kinkl)){ + if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) { delete pmother; delete pdaughter; delete pkink; @@ -4591,18 +5362,18 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) delete pkink; continue; } - Int_t row0= kink.GetTPCRow0(); - if (kink.GetDistance()>0.5 || kink.GetR()<110. || kink.GetR()>240.) { + Int_t row0= kinkl.GetTPCRow0(); + if (kinkl.GetDistance()>0.5 || kinkl.GetR()<110. || kinkl.GetR()>240.) { delete pmother; delete pdaughter; delete pkink; continue; } // - Int_t index = esd->AddKink(&kink); - mother.fKinkIndexes[0] = -(index+1); - daughter.fKinkIndexes[0] = index+1; - if (mother.fN>50) { + Int_t index = esd->AddKink(&kinkl); + mother.SetKinkIndex(0,-(index+1)); + daughter.SetKinkIndex(0,index+1); + if (mother.GetNumberOfClusters()>50) { delete array->RemoveAt(i); array->AddAt(new AliTPCseed(mother),i); } @@ -4611,11 +5382,11 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) } array->AddLast(new AliTPCseed(daughter)); for (Int_t icl=0;iclUse(20); + if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20); } // for (Int_t icl=row0;icl<158;icl++) { - if (daughter.fClusterPointer[icl]) daughter.fClusterPointer[icl]->Use(20); + if (daughter.GetClusterPointer(icl)) daughter.GetClusterPointer(icl)->Use(20); } // } @@ -4646,11 +5417,11 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd) kinks->Delete(); delete kinks; - printf("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall); + AliInfo(Form("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall)); timer.Print(); } -void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) +void AliTPCtrackerMI::FindV0s(const TObjArray * array, AliESDEvent *const esd) { // // find V0s @@ -4696,19 +5467,19 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) // // dca error parrameterezation + pulls // - sdcar[i] = TMath::Sqrt(0.150*0.150+(100*track->fP4)*(100*track->fP4)); - if (TMath::Abs(track->fP3)>1) sdcar[i]*=2.5; - cdcar[i] = TMath::Exp((TMath::Abs(track->fP4)-0.0106)*525.3); + sdcar[i] = TMath::Sqrt(0.150*0.150+(100*track->GetC())*(100*track->GetC())); + if (TMath::Abs(track->GetTgl())>1) sdcar[i]*=2.5; + cdcar[i] = TMath::Exp((TMath::Abs(track->GetC())-0.0106)*525.3); pulldcar[i] = (dca[i]-cdcar[i])/sdcar[i]; pulldcaz[i] = (z0[i]-zvertex)/sdcar[i]; pulldca[i] = TMath::Sqrt(pulldcar[i]*pulldcar[i]+pulldcaz[i]*pulldcaz[i]); - if (track->fTPCr[1]+track->fTPCr[2]+track->fTPCr[3]>0.5) { + if (track->TPCrPID(1)+track->TPCrPID(2)+track->TPCrPID(3)>0.5) { if (pulldca[i]<3.) isPrim[i]=kTRUE; //pion, muon and Kaon 3 sigma cut } - if (track->fTPCr[4]>0.5) { + if (track->TPCrPID(4)>0.5) { if (pulldca[i]<0.5) isPrim[i]=kTRUE; //proton 0.5 sigma cut } - if (track->fTPCr[0]>0.4) { + if (track->TPCrPID(0)>0.4) { isPrim[i]=kFALSE; //electron no sigma cut } } @@ -4725,9 +5496,8 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) // // // // - TTreeSRedirector &cstream = *fDebugStreamer; Float_t fprimvertex[3]={GetX(),GetY(),GetZ()}; - AliESDV0MI vertex; + AliV0 vertex; Double_t cradius0 = 10*10; Double_t cradius1 = 200*200; Double_t cdist1=3.; @@ -4739,20 +5509,23 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) if (sign[i]==0) continue; AliTPCseed * track0 = (AliTPCseed*)array->At(i); if (!track0) continue; - cstream<<"Tracks"<< - "Tr0.="<1){ + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"Tracks"<< + "Tr0.="<fP4<0) continue; + if (track0->GetSigned1Pt()<0) continue; if (track0->GetKinkIndex(0)>0||isPrim[i]) continue; //daughter kink // if (TMath::Abs(helixes[i].GetHelix(4))<0.000000001) continue; @@ -4766,7 +5539,7 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) if (track1->GetKinkIndex(0)>0 || isPrim[j]) continue; //daughter kink if (sign[j]*sign[i]>0) continue; if (TMath::Abs(helixes[j].GetHelix(4))<0.000001) continue; - if (track0->fCircular+track1->fCircular>1) continue; //circling -returning track + if (track0->GetCircular()+track1->GetCircular()>1) continue; //circling -returning track nall++; // // DCA to prim vertex cut @@ -4798,23 +5571,26 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) if (pointAnglefTPCr[0]>0.3&&track1->fTPCr[0]>0.3&&vertex.GetAnglep()[2]<0.15) isGamma=kTRUE; // gamma conversion candidate - Double_t pointAngle2 = vertex.GetPointAngle(); + if (track0->TPCrPID(0)>0.3&&track1->TPCrPID(0)>0.3&&vertex.GetAnglep()[2]<0.15) isGamma=kTRUE; // gamma conversion candidate + Double_t pointAngle2 = vertex.GetV0CosineOfPointingAngle(); //continue; - if (vertex.GetPointAngle()2&&(!isGamma)) continue; // point angle cut + if (vertex.GetV0CosineOfPointingAngle()2&&(!isGamma)) continue; // point angle cut + if (vertex.GetDcaV0Daughters()>2&&(!isGamma)) continue;//Bo: // point angle cut Float_t sigmae = 0.15*0.15; if (vertex.GetRr()<80) sigmae += (sdcar[i]*sdcar[i]+sdcar[j]*sdcar[j])*(1.-vertex.GetRr()/80.)*(1.-vertex.GetRr()/80.); sigmae+= TMath::Sqrt(sigmae); - if (vertex.GetDist2()/sigmae>3.&&(!isGamma)) continue; + //Bo: if (vertex.GetDist2()/sigmae>3.&&(!isGamma)) continue; + if (vertex.GetDcaV0Daughters()/sigmae>3.&&(!isGamma)) continue; Float_t densb0=0,densb1=0,densa0=0,densa1=0; Int_t row0 = GetRowNumber(vertex.GetRr()); if (row0>15){ - if (vertex.GetDist2()>0.2) continue; + //Bo: if (vertex.GetDist2()>0.2) continue; + if (vertex.GetDcaV0Daughters()>0.2) continue; densb0 = track0->Density2(0,row0-5); densb1 = track1->Density2(0,row0-5); if (densb0>0.3|| densb1>0.3) continue; //clusters before vertex @@ -4827,29 +5603,36 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) densa1 = track1->Density2(0,40); //cluster density if ((vertex.GetRr()<80&&densa0+densa1<1.)&&(!isGamma)) continue; } - vertex.SetLab(0,track0->GetLabel()); - vertex.SetLab(1,track1->GetLabel()); +//Bo: vertex.SetLab(0,track0->GetLabel()); +//Bo: vertex.SetLab(1,track1->GetLabel()); vertex.SetChi2After((densa0+densa1)*0.5); vertex.SetChi2Before((densb0+densb1)*0.5); vertex.SetIndex(0,i); vertex.SetIndex(1,j); - vertex.SetStatus(1); // TPC v0 candidate - vertex.SetRp(track0->fTPCr); - vertex.SetRm(track1->fTPCr); - tpcv0s->AddLast(new AliESDV0MI(vertex)); +//Bo: vertex.SetStatus(1); // TPC v0 candidate + vertex.SetOnFlyStatus(2);//Bo: // TPC v0 candidate +//Bo: vertex.SetRp(track0->TPCrPIDs()); +//Bo: vertex.SetRm(track1->TPCrPIDs()); + tpcv0s->AddLast(new AliESDv0(vertex)); ncandidates++; { - Int_t eventNr = esd->GetEventNumber(); + Int_t eventNr = esd->GetEventNumberInFile(); // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number Double_t radiusm= (delta[0]1) { + Int_t lab0=track0->GetLabel(); + Int_t lab1=track1->GetLabel(); + Char_t c0=track0->GetCircular(); + Char_t c1=track1->GetCircular(); + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"V0"<< "Event="<At(i); - quality[i] = 1./(1.00001-v0->GetPointAngle()); //base point angle + AliESDv0 *v0 = (AliESDv0*)tpcv0s->At(i); + quality[i] = 1./(1.00001-v0->GetV0CosineOfPointingAngle()); //base point angle // quality[i] /= (0.5+v0->GetDist2()); // quality[i] *= v0->GetChi2After(); //density factor - Double_t minpulldca = TMath::Min(2.+pulldca[v0->GetIndex(0)],(2.+pulldca[v0->GetIndex(1)]) ); //pull + Int_t index0 = v0->GetIndex(0); Int_t index1 = v0->GetIndex(1); + //Bo: Double_t minpulldca = TMath::Min(2.+pulldca[v0->GetIndex(0)],(2.+pulldca[v0->GetIndex(1)]) ); //pull + Double_t minpulldca = TMath::Min(2.+pulldca[index0],(2.+pulldca[index1]) );//Bo: + + + AliTPCseed * track0 = (AliTPCseed*)array->At(index0); AliTPCseed * track1 = (AliTPCseed*)array->At(index1); - if (track0->fTPCr[0]>0.3&&track1->fTPCr[0]>0.3&&v0->GetAnglep()[2]<0.15) quality[i]+=1000000; // gamma conversion candidate - if (track0->fTPCr[4]>0.9||track1->fTPCr[4]>0.9&&minpulldca>4) quality[i]*=10; // lambda candidate candidate + if (track0->TPCrPID(0)>0.3&&track1->TPCrPID(0)>0.3&&v0->GetAnglep()[2]<0.15) quality[i]+=1000000; // gamma conversion candidate + if (track0->TPCrPID(4)>0.9||(track1->TPCrPID(4)>0.9&&minpulldca>4)) quality[i]*=10; // lambda candidate candidate } TMath::Sort(ncandidates,quality,indexes,kTRUE); // // for (Int_t i=0;iAt(indexes[i]); + AliESDv0 * v0 = (AliESDv0*)tpcv0s->At(indexes[i]); if (!v0) continue; Int_t index0 = v0->GetIndex(0); Int_t index1 = v0->GetIndex(1); @@ -4930,27 +5718,32 @@ void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd) if (v0indexes0[2]!=0) {order0=3; accept=kFALSE;} if (v0indexes0[2]!=0) {order1=3; accept=kFALSE;} // - AliESDV0MI * v02 = v0; + AliESDv0 * v02 = v0; if (accept){ - v0->SetOrder(0,order0); - v0->SetOrder(1,order1); - v0->SetOrder(1,order0+order1); - Int_t index = esd->AddV0MI(v0); - v02 = esd->GetV0MI(index); + //Bo: v0->SetOrder(0,order0); + //Bo: v0->SetOrder(1,order1); + //Bo: v0->SetOrder(1,order0+order1); + v0->SetOnFlyStatus(kTRUE); + Int_t index = esd->AddV0(v0); + v02 = esd->GetV0(index); v0indexes0[order0]=index; v0indexes1[order1]=index; naccepted++; } { - Int_t eventNr = esd->GetEventNumber(); - cstream<<"V02"<< + Int_t eventNr = esd->GetEventNumberInFile(); // This is most likely NOT the event number you'd like to use. It has nothing to do with the 'real' event number + if (AliTPCReconstructor::StreamLevel()>1) { + Int_t lab0=track0->GetLabel(); + Int_t lab1=track1->GetLabel(); + TTreeSRedirector &cstream = *fDebugStreamer; + cstream<<"V02"<< "Event="<240.) continue; if (TMath::Abs(kinks[irow].GetR())<100.) continue; // - Float_t normdist = TMath::Abs(param0[irow].fX-kinks[irow].GetR())*(0.1+kink.GetDistance()); - normdist/= (param0[irow].fN+param1[irow].fN+40.); + Float_t normdist = TMath::Abs(param0[irow].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance()); + normdist/= (param0[irow].GetNumberOfClusters()+param1[irow].GetNumberOfClusters()+40.); if (normdist < mindist){ mindist = normdist; index = irow; @@ -5051,15 +5846,15 @@ Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliES param0[index].Reset(kTRUE); FollowProlongation(param0[index],0); // - new (&mother) AliTPCseed(param0[index]); - new (&daughter) AliTPCseed(param1[index]); // daughter in vertex + mother = param0[index]; + daughter = param1[index]; // daughter in vertex // kink.SetMother(mother); kink.SetDaughter(daughter); kink.Update(); kink.SetTPCRow0(GetRowNumber(kink.GetR())); - kink.SetTPCncls(param0[index].fN,0); - kink.SetTPCncls(param1[index].fN,1); + kink.SetTPCncls(param0[index].GetNumberOfClusters(),0); + kink.SetTPCncls(param1[index].GetNumberOfClusters(),1); kink.SetLabel(CookLabel(&mother,0.4, 0,kink.GetTPCRow0()),0); kink.SetLabel(CookLabel(&daughter,0.4, kink.GetTPCRow0(),160),1); mother.SetLabel(kink.GetLabel(0)); @@ -5079,10 +5874,8 @@ void AliTPCtrackerMI::UpdateKinkQualityM(AliTPCseed * seed){ if (index>=0) break; index = TMath::Abs(index)-1; AliESDkink * kink = fEvent->GetKink(index); - //kink->fTPCdensity2[0][0]=-1; - //kink->fTPCdensity2[0][1]=-1; - kink->SetTPCDensity2(-1,0,0); - kink->SetTPCDensity2(1,0,1); + kink->SetTPCDensity(-1,0,0); + kink->SetTPCDensity(1,0,1); // Int_t row0 = kink->GetTPCRow0() - 2 - Int_t( 0.5/ (0.05+kink->GetAngle(2))); if (row0<15) row0=15; @@ -5092,9 +5885,9 @@ void AliTPCtrackerMI::UpdateKinkQualityM(AliTPCseed * seed){ // Int_t found,foundable,shared; seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE); - if (foundable>5) kink->SetTPCDensity2(Float_t(found)/Float_t(foundable),0,0); + if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,0); seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE); - if (foundable>5) kink->SetTPCDensity2(Float_t(found)/Float_t(foundable),0,1); + if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,1); } } @@ -5109,8 +5902,8 @@ void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){ if (index<=0) break; index = TMath::Abs(index)-1; AliESDkink * kink = fEvent->GetKink(index); - kink->SetTPCDensity2(-1,1,0); - kink->SetTPCDensity2(-1,1,1); + kink->SetTPCDensity(-1,1,0); + kink->SetTPCDensity(-1,1,1); // Int_t row0 = kink->GetTPCRow0() -2 - Int_t( 0.5/ (0.05+kink->GetAngle(2))); if (row0<15) row0=15; @@ -5120,15 +5913,15 @@ void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){ // Int_t found,foundable,shared; seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE); - if (foundable>5) kink->SetTPCDensity2(Float_t(found)/Float_t(foundable),1,0); + if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,0); seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE); - if (foundable>5) kink->SetTPCDensity2(Float_t(found)/Float_t(foundable),1,1); + if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,1); } } -Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink) +Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk) { // // check kink point for given track @@ -5136,20 +5929,21 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP // otherwise seed0 correspond to mother particle // seed1 correspond to daughter particle // kink parameter of kink point + AliKink &kink=(AliKink &)knk; - Int_t middlerow = (seed->fFirstPoint+seed->fLastPoint)/2; - Int_t first = seed->fFirstPoint; - Int_t last = seed->fLastPoint; + Int_t middlerow = (seed->GetFirstPoint()+seed->GetLastPoint())/2; + Int_t first = seed->GetFirstPoint(); + Int_t last = seed->GetLastPoint(); if (last-first<20) return 0; // shortest length - 2*30 = 60 pad-rows AliTPCseed *seed1 = ReSeed(seed,middlerow+20, kTRUE); //middle of chamber if (!seed1) return 0; - FollowProlongation(*seed1,seed->fLastPoint-20); + FollowProlongation(*seed1,seed->GetLastPoint()-20); seed1->Reset(kTRUE); FollowProlongation(*seed1,158); seed1->Reset(kTRUE); - last = seed1->fLastPoint; + last = seed1->GetLastPoint(); // AliTPCseed *seed0 = new AliTPCseed(*seed); seed0->Reset(kFALSE); @@ -5157,7 +5951,7 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP // AliTPCseed param0[20]; // parameters along the track AliTPCseed param1[20]; // parameters along the track - AliESDkink kinks[20]; // corresponding kink parameters + AliKink kinks[20]; // corresponding kink parameters Int_t rows[20]; for (Int_t irow=0; irow<20;irow++){ rows[irow] = first +((last-first)*irow)/19; @@ -5167,8 +5961,8 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP for (Int_t irow=0;irow<20;irow++){ FollowBackProlongation(*seed0, rows[irow]); FollowProlongation(*seed1,rows[19-irow]); - new(¶m0[irow]) AliTPCseed(*seed0); - new(¶m1[19-irow]) AliTPCseed(*seed1); + param0[irow] = *seed0; + param1[19-irow] = *seed1; } // // define kinks @@ -5184,7 +5978,7 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP for (Int_t irow=1;irow<19;irow++){ if (TMath::Abs(kinks[irow].GetR())>240.) continue; if (TMath::Abs(kinks[irow].GetR())<110.) continue; - Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX)); + Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX())); if ( quality > maxchange){ maxchange = quality; index = irow; @@ -5200,15 +5994,15 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP seed1 = new AliTPCseed(param1[index]); seed0->Reset(kFALSE); seed1->Reset(kFALSE); - seed0->ResetCovariance(); - seed1->ResetCovariance(); + seed0->ResetCovariance(10.); + seed1->ResetCovariance(10.); FollowProlongation(*seed0,0); FollowBackProlongation(*seed1,158); - new (&mother) AliTPCseed(*seed0); // backup mother at position 0 + mother = *seed0; // backup mother at position 0 seed0->Reset(kFALSE); seed1->Reset(kFALSE); - seed0->ResetCovariance(); - seed1->ResetCovariance(); + seed0->ResetCovariance(10.); + seed1->ResetCovariance(10.); // first = TMath::Max(row0-20,0); last = TMath::Min(row0+20,158); @@ -5221,8 +6015,8 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP for (Int_t irow=0;irow<20;irow++){ FollowBackProlongation(*seed0, rows[irow]); FollowProlongation(*seed1,rows[19-irow]); - new(¶m0[irow]) AliTPCseed(*seed0); - new(¶m1[19-irow]) AliTPCseed(*seed1); + param0[irow] = *seed0; + param1[19-irow] = *seed1; } // // define kinks @@ -5240,7 +6034,7 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP for (Int_t irow=0;irow<20;irow++){ if (TMath::Abs(kinks[irow].GetR())>250.) continue; if (TMath::Abs(kinks[irow].GetR())<90.) continue; - Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX)); + Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX())); if ( quality > maxchange){ maxchange = quality; index = irow; @@ -5249,33 +6043,61 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP } // // - if (index==-1 || param0[index].fN+param1[index].fN<100){ + if (index==-1 || param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()<100){ delete seed0; delete seed1; return 0; } + // Float_t anglesigma = TMath::Sqrt(param0[index].fC22+param0[index].fC33+param1[index].fC22+param1[index].fC33); kink.SetMother(param0[index]); kink.SetDaughter(param1[index]); kink.Update(); + + Double_t chi2P2 = param0[index].GetParameter()[2]-param1[index].GetParameter()[2]; + chi2P2*=chi2P2; + chi2P2/=param0[index].GetCovariance()[5]+param1[index].GetCovariance()[5]; + Double_t chi2P3 = param0[index].GetParameter()[3]-param1[index].GetParameter()[3]; + chi2P3*=chi2P3; + chi2P3/=param0[index].GetCovariance()[9]+param1[index].GetCovariance()[9]; + // + if (AliTPCReconstructor::StreamLevel()>1) { + (*fDebugStreamer)<<"kinkHpt"<< + "chi2P2="<GetKinkAngleCutChi2(0)){ + delete seed0; + delete seed1; + return 0; + } + + row0 = GetRowNumber(kink.GetR()); kink.SetTPCRow0(row0); kink.SetLabel(CookLabel(seed0,0.5,0,row0),0); kink.SetLabel(CookLabel(seed1,0.5,row0,158),1); kink.SetIndex(-10,0); - kink.SetIndex(int(param0[index].fN+param1[index].fN),1); - kink.SetTPCncls(param0[index].fN,0); - kink.SetTPCncls(param1[index].fN,1); + kink.SetIndex(int(param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()),1); + kink.SetTPCncls(param0[index].GetNumberOfClusters(),0); + kink.SetTPCncls(param1[index].GetNumberOfClusters(),1); // // // new (&mother) AliTPCseed(param0[index]); - new (&daughter) AliTPCseed(param1[index]); + daughter = param1[index]; daughter.SetLabel(kink.GetLabel(1)); param0[index].Reset(kTRUE); - FollowProlongation(param0[index],0); - new (&mother) AliTPCseed(param0[index]); + FollowProlongation(param0[index],0); + mother = param0[index]; mother.SetLabel(kink.GetLabel(0)); + if ( chi2P2+chi2P3GetKinkAngleCutChi2(1)){ + mother=*seed; + } delete seed0; delete seed1; // @@ -5294,11 +6116,11 @@ AliTPCseed* AliTPCtrackerMI::ReSeed(AliTPCseed *t) // Int_t last = fSectors->GetNRows()-1; // if (fSectors == fOuterSec){ - first = TMath::Max(first, t->fFirstPoint-fInnerSec->GetNRows()); + first = TMath::Max(first, t->GetFirstPoint()-fInnerSec->GetNRows()); //last = } else - first = t->fFirstPoint; + first = t->GetFirstPoint(); // AliTPCseed * seed = MakeSeed(t,0.1,0.5,0.9); FollowBackProlongation(*t,fSectors->GetNRows()-1); @@ -5350,7 +6172,7 @@ Int_t AliTPCtrackerMI::ReadSeeds(const TFile *inp) { return 0; } -Int_t AliTPCtrackerMI::Clusters2Tracks (AliESD *esd) +Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *const esd) { // if (fSeeds) DeleteSeeds(); @@ -5358,6 +6180,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks (AliESD *esd) Clusters2Tracks(); if (!fSeeds) return 1; FillESD(fSeeds); + if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(0,fSeeds); return 0; // } @@ -5387,7 +6210,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { continue; } CookLabel(pt,0.1); - if (pt->fRemoval==10) { + if (pt->GetRemoval()==10) { if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7) pt->Desactivate(10); // make track again active else{ @@ -5398,47 +6221,17 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { } // RemoveUsed2(fSeeds,0.85,0.85,0); - FindKinks(fSeeds,fEvent); + if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent); + //FindCurling(fSeeds, fEvent,0); + if (AliTPCReconstructor::StreamLevel()>5) FindMultiMC(fSeeds, fEvent,-1); // find multi found tracks RemoveUsed2(fSeeds,0.5,0.4,20); + FindSplitted(fSeeds, fEvent,0); // find multi found tracks + if (AliTPCReconstructor::StreamLevel()>5) FindMultiMC(fSeeds, fEvent,0); // find multi found tracks + // // // // refit short tracks // // Int_t nseed=fSeeds->GetEntriesFast(); -// for (Int_t i=0; iUncheckedAt(i), &t=*pt; -// if (!pt) continue; -// Int_t nc=t.GetNumberOfClusters(); -// if (nc<15) { -// delete fSeeds->RemoveAt(i); -// continue; -// } -// if (pt->GetKinkIndexes()[0]!=0) continue; // ignore kink candidates -// if (nc>100) continue; // hopefully, enough for ITS -// AliTPCseed *seed2 = new AliTPCseed(*pt); -// //seed2->Reset(kFALSE); -// //pt->ResetCovariance(); -// seed2->Modify(1); -// FollowBackProlongation(*seed2,158); -// //seed2->Reset(kFALSE); -// seed2->Modify(10); -// FollowProlongation(*seed2,0); -// TTreeSRedirector &cstream = *fDebugStreamer; -// cstream<<"Crefit"<< -// "Tr0.="<fN>pt->fN){ -// delete fSeeds->RemoveAt(i); -// fSeeds->AddAt(seed2,i); -// }else{ -// delete seed2; -// } -// } -// RemoveUsed2(fSeeds,0.6,0.6,50); - -// FindV0s(fSeeds,fEvent); - //RemoveDouble(fSeeds,0.2,0.6,11); - // Int_t found = 0; for (Int_t i=0; iIsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){ - if ((pt->IsActive() || (pt->fRemoval==10) )){ + if ((pt->IsActive() || (pt->GetRemoval()==10) )){ found++; if (fDebug>0) cerr<fLab2 = i; + pt->SetLab2(i); } else delete fSeeds->RemoveAt(i); @@ -5479,12 +6272,12 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { t.CookdEdx(0.02,0.6); // CheckKinkPoint(&t,0.05); //if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){ - if ((pt->IsActive() || (pt->fRemoval==10) )){ + if ((pt->IsActive() || (pt->GetRemoval()==10) )){ found++; if (fDebug>0){ cerr<fLab2 = i; + pt->SetLab2(i); } else delete fSeeds->RemoveAt(i); @@ -5596,12 +6389,16 @@ TObjArray * AliTPCtrackerMI::Tracking() { // // + if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial(); TStopwatch timer; timer.Start(); Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows(); TObjArray * seeds = new TObjArray; TObjArray * arr=0; + Int_t fLastSeedRowSec=AliTPCReconstructor::GetRecoParam()->GetLastSeedRowSec(); + Int_t gapPrim = AliTPCReconstructor::GetRecoParam()->GetSeedGapPrim(); + Int_t gapSec = AliTPCReconstructor::GetRecoParam()->GetSeedGapSec(); Int_t gap =20; Float_t cuts[4]; @@ -5615,7 +6412,7 @@ TObjArray * AliTPCtrackerMI::Tracking() // //find primaries cuts[0]=0.0066; - for (Int_t delta = 0; delta<18; delta+=6){ + for (Int_t delta = 0; delta<18; delta+=gapPrim){ // cuts[0]=0.0070; cuts[1] = 1.5; @@ -5640,7 +6437,7 @@ TObjArray * AliTPCtrackerMI::Tracking() //find primaries cuts[0]=0.0077; - for (Int_t delta = 20; delta<120; delta+=10){ + for (Int_t delta = 20; delta<120; delta+=gapPrim){ // // seed high pt tracks cuts[0]=0.0060; @@ -5693,9 +6490,22 @@ TObjArray * AliTPCtrackerMI::Tracking() SumTracks(seeds,arr); SignClusters(seeds,fnumber,fdensity); // + arr = Tracking(4,nup-5,nup-5-gap,cuts,-1); + SumTracks(seeds,arr); + SignClusters(seeds,fnumber,fdensity); + // + arr = Tracking(4,nup-7,nup-7-gap,cuts,-1); + SumTracks(seeds,arr); + SignClusters(seeds,fnumber,fdensity); + // + // + arr = Tracking(4,nup-9,nup-9-gap,cuts,-1); + SumTracks(seeds,arr); + SignClusters(seeds,fnumber,fdensity); + // - for (Int_t delta = 3; delta<30; delta+=5){ + for (Int_t delta = 9; delta<30; delta+=gapSec){ // cuts[0] = 0.3; cuts[1] = 1.5; @@ -5718,8 +6528,9 @@ TObjArray * AliTPCtrackerMI::Tracking() fdensity = 2.; cuts[0]=0.0080; + // find secondaries - for (Int_t delta = 30; delta<90; delta+=10){ + for (Int_t delta = 30; deltaGetNRows()+fInnerSec->GetNRows(); + + TObjArray * seeds = new TObjArray; + TObjArray * arr=0; + + Int_t gap = 15; + Float_t cuts[4]; + Float_t fnumber = 3.0; + Float_t fdensity = 3.0; + + // find secondaries + cuts[0] = AliTPCReconstructor::GetRecoParam()->GetMaxC(); // max curvature + cuts[1] = 3.5; // max tan(phi) angle for seeding + cuts[2] = 3.; // not used (cut on z primary vertex) + cuts[3] = 3.5; // max tan(theta) angle for seeding + + for (Int_t delta = 0; nup-delta-gap-1>0; delta+=3){ + // + arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1); + SumTracks(seeds,arr); + SignClusters(seeds,fnumber,fdensity); + } + + if (fDebug>0){ + Info("Tracking()","\n\nSecondary seeding\t%d\n\n",seeds->GetEntriesFast()); + timer.Print(); + timer.Start(); + } + + return seeds; + // + +} + + +void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *&arr2) const { // //sum tracks to common container @@ -5755,22 +6609,29 @@ void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const for (Int_t i=0;iUncheckedAt(i); if (pt){ - + // + // remove tracks with too big curvature + // + if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){ + delete arr2->RemoveAt(i); + continue; + } + // REMOVE VERY SHORT TRACKS + if (pt->GetNumberOfClusters()<20){ + delete arr2->RemoveAt(i); + continue; + }// patch 28 fev06 // NORMAL ACTIVE TRACK if (pt->IsActive()){ arr1->AddLast(arr2->RemoveAt(i)); continue; } //remove not usable tracks - if (pt->fRemoval!=10){ - delete arr2->RemoveAt(i); - continue; - } - // REMOVE VERY SHORT TRACKS - if (pt->GetNumberOfClusters()<20){ + if (pt->GetRemoval()!=10){ delete arr2->RemoveAt(i); continue; } + // ENABLE ONLY ENOUGH GOOD STOPPED TRACKS if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7) arr1->AddLast(arr2->RemoveAt(i)); @@ -5779,12 +6640,12 @@ void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const } } } - delete arr2; + delete arr2; arr2 = 0; } -void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rlast) +void AliTPCtrackerMI::ParallelTracking(TObjArray *const arr, Int_t rfirst, Int_t rlast) { // // try to track in parralel @@ -5796,7 +6657,7 @@ void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla if (!pt) continue; if (!t.IsActive()) continue; // follow prolongation to the first layer - if ( (fSectors ==fInnerSec) || (t.fFirstPoint-fParam->GetNRowLow()>rfirst+1) ) + if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fkParam->GetNRowLow()>rfirst+1) ) FollowProlongation(t, rfirst+1); } @@ -5815,8 +6676,8 @@ void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla if (!pt) continue; if (nr==80) pt->UpdateReference(); if (!pt->IsActive()) continue; - // if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())fRelativeSector>17) { + // if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())GetRelativeSector()>17) { continue; } UpdateClusters(t,nr); @@ -5826,8 +6687,8 @@ void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i); if (!pt) continue; if (!pt->IsActive()) continue; - // if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())fRelativeSector>17) { + // if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fkParam->GetNRowLow())GetRelativeSector()>17) { continue; } FollowToNextCluster(*pt,nr); @@ -5835,7 +6696,7 @@ void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla } } -void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) const +void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray *const arr,Float_t fac) const { // // @@ -5848,7 +6709,7 @@ void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) co pt->Modify(fac); // //rotate to current local system at first accepted point - Int_t index = pt->GetClusterIndex2(pt->fFirstPoint); + Int_t index = pt->GetClusterIndex2(pt->GetFirstPoint()); Int_t sec = (index&0xff000000)>>24; sec = sec%18; Float_t angle1 = fInnerSec->GetAlpha()*sec+fInnerSec->GetAlphaShift(); @@ -5871,7 +6732,7 @@ void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) co } -void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const +void AliTPCtrackerMI::PrepareForProlongation(TObjArray *const arr, Float_t fac) const { // // @@ -5882,7 +6743,7 @@ void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i); if (pt) { pt->Modify(fac); - pt->fFirstPoint = pt->fLastPoint; + pt->SetFirstPoint(pt->GetLastPoint()); } } @@ -5890,7 +6751,7 @@ void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const } -Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) +Int_t AliTPCtrackerMI::PropagateBack(TObjArray *const arr) { // // make back propagation @@ -5911,17 +6772,17 @@ Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) } if (pt&& pt->GetKinkIndex(0)>0) { AliESDkink * kink = fEvent->GetKink(pt->GetKinkIndex(0)-1); - pt->fFirstPoint = kink->GetTPCRow0(); + pt->SetFirstPoint(kink->GetTPCRow0()); fSectors = fInnerSec; FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1); } - + CookLabel(pt,0.3); } return 0; } -Int_t AliTPCtrackerMI::PropagateForward2(TObjArray * arr) +Int_t AliTPCtrackerMI::PropagateForward2(TObjArray *const arr) { // // make forward propagation @@ -5932,7 +6793,9 @@ Int_t AliTPCtrackerMI::PropagateForward2(TObjArray * arr) AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i); if (pt) { FollowProlongation(*pt,0); + CookLabel(pt,0.3); } + } return 0; } @@ -5951,7 +6814,7 @@ Int_t AliTPCtrackerMI::PropagateForward() Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift(); if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); - t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN; + t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN); } } @@ -5959,7 +6822,6 @@ Int_t AliTPCtrackerMI::PropagateForward() ParallelTracking(fSeeds,fOuterSec->GetNRows()+fInnerSec->GetNRows()-1,fInnerSec->GetNRows()); fSectors = fInnerSec; ParallelTracking(fSeeds,fInnerSec->GetNRows()-1,0); - //WriteTracks(); return 1; } @@ -5968,7 +6830,7 @@ Int_t AliTPCtrackerMI::PropagateForward() -Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed * pt, Int_t row0, Int_t row1) +Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed *const pt, Int_t row0, Int_t row1) { // // make back propagation, in between row0 and row1 @@ -6003,19 +6865,27 @@ Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed * pt, Int_t row0, Int_t row1) void AliTPCtrackerMI::GetShape(AliTPCseed * seed, Int_t row) { // - // - Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL(); - // Float_t padlength = fParam->GetPadPitchLength(seed->fSector); - Float_t padlength = GetPadPitchLength(row); - // - Float_t sresy = (seed->fSector < fParam->GetNSector()/2) ? 0.2 :0.3; - Float_t angulary = seed->GetSnp(); - angulary = angulary*angulary/(1-angulary*angulary); - seed->fCurrentSigmaY2 = sd2+padlength*padlength*angulary/12.+sresy*sresy; - // - Float_t sresz = fParam->GetZSigma(); - Float_t angularz = seed->GetTgl(); - seed->fCurrentSigmaZ2 = sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz; + // + AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); + Float_t zdrift = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ()))); + Int_t type = (seed->GetSector() < fkParam->GetNSector()/2) ? 0: (row>126) ? 1:2; + Double_t angulary = seed->GetSnp(); + angulary = angulary*angulary/((1.-angulary)*(1.+angulary)); + Double_t angularz = seed->GetTgl()*seed->GetTgl()*(1.+angulary); + + Double_t sigmay = clparam->GetRMS0(0,type,zdrift,TMath::Sqrt(TMath::Abs(angulary))); + Double_t sigmaz = clparam->GetRMS0(1,type,zdrift,TMath::Sqrt(TMath::Abs(angularz))); + seed->SetCurrentSigmaY2(sigmay*sigmay); + seed->SetCurrentSigmaZ2(sigmaz*sigmaz); + // Float_t sd2 = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fkParam->GetDiffL()*fkParam->GetDiffL(); +// // Float_t padlength = fkParam->GetPadPitchLength(seed->fSector); +// Float_t padlength = GetPadPitchLength(row); +// // +// Float_t sresy = (seed->GetSector() < fkParam->GetNSector()/2) ? 0.2 :0.3; +// seed->SetCurrentSigmaY2(sd2+padlength*padlength*angulary/12.+sresy*sresy); +// // +// Float_t sresz = fkParam->GetZSigma(); +// seed->SetCurrentSigmaZ2(sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz); /* Float_t wy = GetSigmaY(seed); Float_t wz = GetSigmaZ(seed); @@ -6028,39 +6898,18 @@ void AliTPCtrackerMI::GetShape(AliTPCseed * seed, Int_t row) } -Float_t AliTPCtrackerMI::GetSigmaY(AliTPCseed * seed) -{ - // - // - Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL(); - Float_t padlength = fParam->GetPadPitchLength(seed->fSector); - Float_t sres = (seed->fSector < fParam->GetNSector()/2) ? 0.2 :0.3; - Float_t angular = seed->GetSnp(); - angular = angular*angular/(1-angular*angular); - // angular*=angular; - //angular = TMath::Sqrt(angular/(1-angular)); - Float_t res = TMath::Sqrt(sd2+padlength*padlength*angular/12.+sres*sres); - return res; -} -Float_t AliTPCtrackerMI::GetSigmaZ(AliTPCseed * seed) -{ - // - // - Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL(); - Float_t padlength = fParam->GetPadPitchLength(seed->fSector); - Float_t sres = fParam->GetZSigma(); - Float_t angular = seed->GetTgl(); - Float_t res = TMath::Sqrt(sd2+padlength*padlength*angular*angular/12.+sres*sres); - return res; -} - //__________________________________________________________________________ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const { //-------------------------------------------------------------------- //This function "cooks" a track label. If label<0, this track is fake. //-------------------------------------------------------------------- - AliTPCseed * t = (AliTPCseed*)tk; + AliTPCseed * t = dynamic_cast(tk); + if(!t){ + printf("%s:%d wrong type \n",(char*)__FILE__,__LINE__); + return; + } + Int_t noc=t->GetNumberOfClusters(); if (noc<10){ //printf("\nnot founded prolongation\n\n\n"); @@ -6085,8 +6934,8 @@ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const { if (index&0x8000) continue; // //clusters[current]=GetClusterMI(index); - if (t->fClusterPointer[i]){ - clusters[current]=t->fClusterPointer[i]; + if (t->GetClusterPointer(i)){ + clusters[current]=t->GetClusterPointer(i); current++; } } @@ -6112,8 +6961,8 @@ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const { if (TMath::Abs(c->GetLabel(1)) == lab || TMath::Abs(c->GetLabel(2)) == lab ) max++; } - - if ((1.- Float_t(max)/noc) > wrong) lab=-lab; + if (noc<=0) { lab=-1; return;} + if ((1.- Float_t(max)/(noc)) > wrong) lab=-lab; else { Int_t tail=Int_t(0.10*noc); @@ -6140,7 +6989,7 @@ void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const { //__________________________________________________________________________ -Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong,Int_t first, Int_t last) const { +Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *const t, Float_t wrong,Int_t first, Int_t last) const { //-------------------------------------------------------------------- //This function "cooks" a track label. If label<0, this track is fake. //-------------------------------------------------------------------- @@ -6169,8 +7018,8 @@ Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong,Int_t first, Int_t if (index&0x8000) continue; // //clusters[current]=GetClusterMI(index); - if (t->fClusterPointer[i]){ - clusters[current]=t->fClusterPointer[i]; + if (t->GetClusterPointer(i)){ + clusters[current]=t->GetClusterPointer(i); current++; } } @@ -6196,8 +7045,8 @@ Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong,Int_t first, Int_t if (TMath::Abs(c->GetLabel(1)) == lab || TMath::Abs(c->GetLabel(2)) == lab ) max++; } - - if ((1.- Float_t(max)/noc) > wrong) lab=-lab; + if (noc<=0) { lab=-1; return -1;} + if ((1.- Float_t(max)/(noc)) > wrong) lab=-lab; else { Int_t tail=Int_t(0.10*noc); @@ -6223,29 +7072,6 @@ Int_t AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong,Int_t first, Int_t } -Int_t AliTPCtrackerMI::AliTPCSector::GetRowNumber(Double_t x) const -{ - //return pad row number for this x - Double_t r; - if (fN < 64){ - r=fRow[fN-1].GetX(); - if (x > r) return fN; - r=fRow[0].GetX(); - if (x < r) return -1; - return Int_t((x-r)/fPadPitchLength + 0.5);} - else{ - r=fRow[fN-1].GetX(); - if (x > r) return fN; - r=fRow[0].GetX(); - if (x < r) return -1; - Double_t r1=fRow[64].GetX(); - if(xGetInnerAngle(); - fAlphaShift=par->GetInnerAngleShift(); - fPadPitchWidth=par->GetInnerPadPitchWidth(); - fPadPitchLength=par->GetInnerPadPitchLength(); - fN=par->GetNRowLow(); - fRow=new AliTPCRow[fN]; - for (Int_t i=0; iGetPadRowRadiiLow(i)); - fRow[i].fDeadZone =1.5; //1.5 cm of dead zone - } - } else { - fAlpha=par->GetOuterAngle(); - fAlphaShift=par->GetOuterAngleShift(); - fPadPitchWidth = par->GetOuterPadPitchWidth(); - fPadPitchLength = par->GetOuter1PadPitchLength(); - f1PadPitchLength = par->GetOuter1PadPitchLength(); - f2PadPitchLength = par->GetOuter2PadPitchLength(); - - fN=par->GetNRowUp(); - fRow=new AliTPCRow[fN]; - for (Int_t i=0; iGetPadRowRadiiUp(i)); - fRow[i].fDeadZone =1.5; // 1.5 cm of dead zone - } - } -} - -AliTPCtrackerMI::AliTPCRow::AliTPCRow() { - // - // default constructor - fN=0; - fN1=0; - fN2=0; - fClusters1=0; - fClusters2=0; -} - -AliTPCtrackerMI::AliTPCRow::~AliTPCRow(){ - // - -} - -//_________________________________________________________________________ -void -AliTPCtrackerMI::AliTPCRow::InsertCluster(const AliTPCclusterMI* c, UInt_t index) { - //----------------------------------------------------------------------- - // Insert a cluster into this pad row in accordence with its y-coordinate - //----------------------------------------------------------------------- - if (fN==kMaxClusterPerRow) { - cerr<<"AliTPCRow::InsertCluster(): Too many clusters !\n"; return; - } - if (fN==0) {fIndex[0]=index; fClusters[fN++]=c; return;} - Int_t i=Find(c->GetZ()); - memmove(fClusters+i+1 ,fClusters+i,(fN-i)*sizeof(AliTPCclusterMI*)); - memmove(fIndex +i+1 ,fIndex +i,(fN-i)*sizeof(UInt_t)); - fIndex[i]=index; fClusters[i]=c; fN++; -} - -void AliTPCtrackerMI::AliTPCRow::ResetClusters() { - // - // reset clusters - fN = 0; - fN1 = 0; - fN2 = 0; - //delete[] fClusterArray; - if (fClusters1) delete []fClusters1; - if (fClusters2) delete []fClusters2; - //fClusterArray=0; - fClusters1 = 0; - fClusters2 = 0; -} - - -//___________________________________________________________________ -Int_t AliTPCtrackerMI::AliTPCRow::Find(Double_t z) const { +void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t) +{ //----------------------------------------------------------------------- - // Return the index of the nearest cluster + // Fill the cluster and sharing bitmaps of the track //----------------------------------------------------------------------- - if (fN==0) return 0; - if (z <= fClusters[0]->GetZ()) return 0; - if (z > fClusters[fN-1]->GetZ()) return fN; - Int_t b=0, e=fN-1, m=(b+e)/2; - for (; b fClusters[m]->GetZ()) b=m+1; - else e=m; - } - return m; -} - - -//___________________________________________________________________ -AliTPCclusterMI * AliTPCtrackerMI::AliTPCRow::FindNearest(Double_t y, Double_t z, Double_t roady, Double_t roadz) const { - //----------------------------------------------------------------------- - // Return the index of the nearest cluster in z y - //----------------------------------------------------------------------- - Float_t maxdistance = roady*roady + roadz*roadz; - - AliTPCclusterMI *cl =0; - for (Int_t i=Find(z-roadz); iGetZ() > z+roadz) break; - if ( (c->GetY()-y) > roady ) continue; - Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y); - if (maxdistance>distance) { - maxdistance = distance; - cl=c; - } + Int_t firstpoint = 0; + Int_t lastpoint = 159; + AliTPCTrackerPoint *point; + AliTPCclusterMI *cluster; + + for (int iter=firstpoint; iterGetClusterPointer(iter); + if (cluster) { + t->SetClusterMapBit(iter, kTRUE); + point = t->GetTrackPoint(iter); + if (point->IsShared()) + t->SetSharedMapBit(iter,kTRUE); + else + t->SetSharedMapBit(iter, kFALSE); + } + else { + t->SetClusterMapBit(iter, kFALSE); + t->SetSharedMapBit(iter, kFALSE); + } } - return cl; } -AliTPCclusterMI * AliTPCtrackerMI::AliTPCRow::FindNearest2(Double_t y, Double_t z, Double_t roady, Double_t roadz,UInt_t & index) const -{ - //----------------------------------------------------------------------- - // Return the index of the nearest cluster in z y - //----------------------------------------------------------------------- - Float_t maxdistance = roady*roady + roadz*roadz; - AliTPCclusterMI *cl =0; - - //PH Check boundaries. 510 is the size of fFastCluster - Int_t iz1 = Int_t(z-roadz+254.5); - if (iz1<0 || iz1>=510) return cl; - iz1 = TMath::Max(fFastCluster[iz1]-1,0); - Int_t iz2 = Int_t(z+roadz+255.5); - if (iz2<0 || iz2>=510) return cl; - iz2 = TMath::Min(fFastCluster[iz2]+1,fN); - - //FindNearest3(y,z,roady,roadz,index); - // for (Int_t i=Find(z-roadz); iGetZ() > z+roadz) break; - if ( c->GetY()-y > roady ) continue; - if ( y-c->GetY() > roady ) continue; - Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y); - if (maxdistance>distance) { - maxdistance = distance; - cl=c; - index =i; - //roady = TMath::Sqrt(maxdistance); - } - } - return cl; +Bool_t AliTPCtrackerMI::IsFindable(AliTPCseed & track){ + // + // return flag if there is findable cluster at given position + // + Float_t kDeltaZ=10; + Float_t z = track.GetZ(); + + if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*track.GetX()+kDeltaZ) && + TMath::Abs(z)GetZLength(0) && + (TMath::Abs(track.GetSnp())GetZ() > z+roadz) break; - if ( c->GetY()-y > roady ) continue; - if ( y-c->GetY() > roady ) continue; - Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y); - if (maxdistance>distance) { - maxdistance = distance; - cl=c; - index =i; - //roady = TMath::Sqrt(maxdistance); - } - } - return cl; + const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError(); + Double_t *covarIn= (Double_t*)seed->GetCovariance(); + Double_t covar[15]; + for (Int_t i=0;i<15;i++) covar[i]=0; + // 0 + // 1 2 + // 3 4 5 + // 6 7 8 9 + // 10 11 12 13 14 + covar[0] = param[0]*param[0]; + covar[2] = param[1]*param[1]; + covar[5] = param[2]*param[2]; + covar[9] = param[3]*param[3]; + Double_t facC = AliTracker::GetBz()*kB2C; + covar[14]= param[4]*param[4]*facC*facC; + // + covar[1]=TMath::Sqrt((covar[0]*covar[2]))*covarIn[1]/TMath::Sqrt((covarIn[0]*covarIn[2])); + // + covar[3]=TMath::Sqrt((covar[0]*covar[5]))*covarIn[3]/TMath::Sqrt((covarIn[0]*covarIn[5])); + covar[4]=TMath::Sqrt((covar[2]*covar[5]))*covarIn[4]/TMath::Sqrt((covarIn[2]*covarIn[5])); + // + covar[6]=TMath::Sqrt((covar[0]*covar[9]))*covarIn[6]/TMath::Sqrt((covarIn[0]*covarIn[9])); + covar[7]=TMath::Sqrt((covar[2]*covar[9]))*covarIn[7]/TMath::Sqrt((covarIn[2]*covarIn[9])); + covar[8]=TMath::Sqrt((covar[5]*covar[9]))*covarIn[8]/TMath::Sqrt((covarIn[5]*covarIn[9])); + // + covar[10]=TMath::Sqrt((covar[0]*covar[14]))*covarIn[10]/TMath::Sqrt((covarIn[0]*covarIn[14])); + covar[11]=TMath::Sqrt((covar[2]*covar[14]))*covarIn[11]/TMath::Sqrt((covarIn[2]*covarIn[14])); + covar[12]=TMath::Sqrt((covar[5]*covar[14]))*covarIn[12]/TMath::Sqrt((covarIn[5]*covarIn[14])); + covar[13]=TMath::Sqrt((covar[9]*covar[14]))*covarIn[13]/TMath::Sqrt((covarIn[9]*covarIn[14])); + // + seed->AddCovariance(covar); } - - - - - -// AliTPCTrackerPoint * AliTPCseed::GetTrackPoint(Int_t i) -// { -// // -// // -// return &fTrackPoints[i]; -// } - -