X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCtrackerMI.cxx;h=68aa0da4a097c532fb526e2f7ce8589caeca5029;hb=777fcfdefff33ea58f08f3bb05cf22c85cbec2ea;hp=44448d118348a91a195216798869a2751c9fb4ca;hpb=af86c1fd9f539a1a1925a3371e8c26f6d83f2e14;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCtrackerMI.cxx b/TPC/AliTPCtrackerMI.cxx index 44448d11834..68aa0da4a09 100644 --- a/TPC/AliTPCtrackerMI.cxx +++ b/TPC/AliTPCtrackerMI.cxx @@ -67,20 +67,42 @@ // // 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); where nis bigger 0 +// 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 (Log level 9) - dump information about +// 1. ErrParam stream - dump information about // 1.a) cluster // 2.a) cluster error estimate // 3.a) cluster shape estimate // // +// Debug streamer levels: +// //------------------------------------------------------- @@ -91,6 +113,7 @@ #include #include #include +#include #include "AliLog.h" #include "AliComplexCluster.h" #include "AliESDEvent.h" @@ -105,24 +128,27 @@ #include "AliTPCReconstructor.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 "AliPID.h" -#include "TTreeStream.h" #include "AliAlignObj.h" #include "AliTrackPointArray.h" #include "TRandom.h" #include "AliTPCcalibDB.h" +#include "AliTPCcalibDButil.h" #include "AliTPCTransform.h" #include "AliTPCClusterParam.h" +#include "AliTPCdEdxInfo.h" // ClassImp(AliTPCtrackerMI) + class AliTPCFastMath { public: AliTPCFastMath(); @@ -173,12 +199,19 @@ AliTPCtrackerMI::AliTPCtrackerMI() fNtracks(0), fSeeds(0), fIteration(0), - fParam(0), - fDebugStreamer(0) + fkParam(0), + fDebugStreamer(0), + fUseHLTClusters(4) { // // default constructor // + for (Int_t irow=0; irow<200; irow++){ + fXRow[irow]=0; + fYMax[irow]=0; + fPadLength[irow]=0; + } + } //_____________________________________________________________________ @@ -190,8 +223,10 @@ Int_t AliTPCtrackerMI::UpdateTrack(AliTPCseed * track, Int_t accept){ AliTPCclusterMI* c =track->GetCurrentCluster(); - if (accept>0) track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000); //sign not accepted clusters - + if (accept > 0) //sign not accepted clusters + track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000); + else // unsign accpeted clusters + track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() & 0xffff7fff); UInt_t i = track->GetCurrentClusterIndex1(); Int_t sec=(i&0xff000000)>>24; @@ -199,7 +234,7 @@ Int_t AliTPCtrackerMI::UpdateTrack(AliTPCseed * track, Int_t accept){ track->SetRow((i&0x00ff0000)>>16); track->SetSector(sec); // Int_t index = i&0xFFFF; - if (sec>=fParam->GetNInnerSector()) track->SetRow(track->GetRow()+fParam->GetNRowLow()); + if (sec>=fkParam->GetNInnerSector()) track->SetRow(track->GetRow()+fkParam->GetNRowLow()); track->SetClusterIndex2(track->GetRow(), i); //track->fFirstPoint = row; //if ( track->fLastPointfLastPoint =row; @@ -266,32 +301,48 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste // // decide according desired precision to accept given // cluster for tracking + 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->GetCurrentCluster()->GetY()-seed->GetY())* - (seed->GetCurrentCluster()->GetY()-seed->GetY())/sdistancey2; - Double_t rdistancez2 = (seed->GetCurrentCluster()->GetZ()-seed->GetZ())* - (seed->GetCurrentCluster()->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 (AliTPCReconstructor::StreamLevel()>5) { + 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]; - AliExternalTrackParam param(*seed); + + if (AliTPCReconstructor::StreamLevel()>2) { (*fDebugStreamer)<<"ErrParam"<< "Cl.="<16) return 3; + //return 0; // temporary + if (rdistance2>32) return 3; if ((rdistancey2>9. || rdistancez2>9.) && cluster->GetType()==0) @@ -318,12 +374,21 @@ Int_t AliTPCtrackerMI::AcceptCluster(AliTPCseed * seed, AliTPCclusterMI * cluste seed->SetNFoundable(seed->GetNFoundable()-1); return 2; } + + if (fUseHLTClusters == 3 || fUseHLTClusters == 4) { + if(!AliTPCReconstructor::GetRecoParam()->GetUseHLTOnePadCluster()) { + if (TMath::Abs(cluster->GetSigmaY2()) < kAlmost0) + return 2; + } + } + return 0; } + //_____________________________________________________________________________ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCParam *par): AliTracker(), @@ -343,38 +408,42 @@ AliTracker(), fNtracks(0), fSeeds(0), fIteration(0), - fParam(0), - fDebugStreamer(0) + fkParam(0), + fDebugStreamer(0), + fUseHLTClusters(4) + { //--------------------------------------------------------------------- // 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()); } - fDebugStreamer = new TTreeSRedirector("TPCdebug.root"); + if (AliTPCReconstructor::StreamLevel()>0) { + fDebugStreamer = new TTreeSRedirector("TPCdebug.root"); + } } //________________________________________________________________________ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t): @@ -395,15 +464,23 @@ AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t): fNtracks(0), fSeeds(0), fIteration(0), - fParam(0), - fDebugStreamer(0) + fkParam(0), + fDebugStreamer(0), + fUseHLTClusters(4) { //------------------------------------ // dummy copy constructor //------------------------------------------------------------------ fOutput=t.fOutput; + for (Int_t irow=0; irow<200; irow++){ + fXRow[irow]=0; + fYMax[irow]=0; + fPadLength[irow]=0; + } + } -AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/){ +AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/) +{ //------------------------------ // dummy //-------------------------------------------------------------- @@ -424,12 +501,13 @@ AliTPCtrackerMI::~AliTPCtrackerMI() { } -void AliTPCtrackerMI::FillESD(TObjArray* arr) +void AliTPCtrackerMI::FillESD(const TObjArray* arr) { // // //fill esds using updated tracks - if (fEvent){ + if (!fEvent) return; + // write tracks to the event // store index of the track Int_t nseed=arr->GetEntriesFast(); @@ -438,9 +516,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){ @@ -538,22 +622,39 @@ void AliTPCtrackerMI::FillESD(TObjArray* arr) continue; } } - } - printf("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks()); + // >> 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) + AliInfo(Form("Number of filled ESDs-\t%d\n",fEvent->GetNumberOfTracks())); + } -Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ +Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, const AliTPCclusterMI * cl){ // // // Use calibrated cluster error from OCDB // AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); // - Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ())); + 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(); @@ -601,7 +702,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -611,7 +712,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -622,7 +723,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -639,7 +740,7 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ // return 1.; // } // Float_t snoise2; -// Float_t z = TMath::Abs(fParam->GetZLength(0)-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->GetRow()); // Double_t angle2 = seed->GetSnp()*seed->GetSnp(); @@ -696,14 +797,14 @@ Double_t AliTPCtrackerMI::ErrY2(AliTPCseed* seed, AliTPCclusterMI * cl){ -Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ +Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, const AliTPCclusterMI * cl){ // // // Use calibrated cluster error from OCDB // AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); // - Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ())); + 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; // @@ -757,7 +858,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -767,7 +868,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -778,7 +879,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ // 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; +// 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.; @@ -795,7 +896,7 @@ Double_t AliTPCtrackerMI::ErrZ2(AliTPCseed* seed, AliTPCclusterMI * cl){ // return 1.; // } // Float_t snoise2; -// Float_t z = TMath::Abs(fParam->GetZLength(0)-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->GetRow()); // // @@ -881,7 +982,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 @@ -902,7 +1003,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 @@ -913,7 +1014,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; } // @@ -928,7 +1029,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 @@ -939,7 +1040,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; } // @@ -958,7 +1059,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 @@ -977,7 +1078,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 @@ -988,7 +1089,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 @@ -1008,7 +1109,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. //----------------------------------------------------------------- @@ -1019,8 +1120,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]; @@ -1043,38 +1144,38 @@ 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) { - // + // load clusters // fInput = tree; return LoadClusters(); } -Int_t AliTPCtrackerMI::LoadClusters(TObjArray *arr) +Int_t AliTPCtrackerMI::LoadClusters(const TObjArray *arr) { // // load clusters to the memory - AliTPCClustersRow *clrow = 0x0; + 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; - + if(!clrow) continue; + if(!clrow->GetArray()) continue; + // 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))); } // if (clrow->GetArray()->GetEntriesFast()<=0) continue; - AliTPCRow * tpcrow=0; + AliTPCtrackerRow * tpcrow=0; Int_t left=0; if (secSetN1(clrow->GetArray()->GetEntriesFast()); tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]); - for (Int_t i=0;iGetN1();i++) - tpcrow->SetCluster1(i, *(AliTPCclusterMI*)(clrow->GetArray()->At(i))); + 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 i=0;iGetN2();i++) - tpcrow->SetCluster2(i,*(AliTPCclusterMI*)(clrow->GetArray()->At(i))); + for (Int_t j=0;jGetN2();++j) + tpcrow->SetCluster2(j,*(AliTPCclusterMI*)(clrow->GetArray()->At(j))); } + clrow->GetArray()->Clear("C"); } // delete clrow; @@ -1104,33 +1206,90 @@ Int_t AliTPCtrackerMI::LoadClusters(TObjArray *arr) 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(); TTree * tree = fInput; TBranch * br = tree->GetBranch("Segment"); br->SetAddress(&clrow); - // + + // Conversion of pad, row coordinates in local tracking coords. + // Could be skipped here; is already done in clusterfinder + Int_t j=Int_t(tree->GetEntries()); for (Int_t i=0; iGetEntry(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 (secSetN1(clrow->GetArray()->GetEntriesFast()); tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]); - for (Int_t i=0;iGetN1();i++) - tpcrow->SetCluster1(i, *(AliTPCclusterMI*)(clrow->GetArray()->At(i))); + for (Int_t k=0;kGetN1();++k) + tpcrow->SetCluster1(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k))); } if (left ==1){ tpcrow->SetN2(clrow->GetArray()->GetEntriesFast()); tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]); - for (Int_t i=0;iGetN2();i++) - tpcrow->SetCluster2(i,*(AliTPCclusterMI*)(clrow->GetArray()->At(i))); + for (Int_t k=0;kGetN2();++k) + tpcrow->SetCluster2(k,*(AliTPCclusterMI*)(clrow->GetArray()->At(k))); } } // @@ -1169,7 +1328,7 @@ void AliTPCtrackerMI::UnloadClusters() Int_t nrows = fOuterSec->GetNRows(); for (Int_t sec = 0;secfClusters1) delete []tpcrow->fClusters1; // if (tpcrow->fClusters2) delete []tpcrow->fClusters2; @@ -1180,7 +1339,7 @@ void AliTPCtrackerMI::UnloadClusters() nrows = fInnerSec->GetNRows(); for (Int_t sec = 0;secfClusters1) delete []tpcrow->fClusters1; //if (tpcrow->fClusters2) delete []tpcrow->fClusters2; @@ -1191,31 +1350,60 @@ void AliTPCtrackerMI::UnloadClusters() return ; } -void AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){ +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){ // + // transformation // - AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ; + AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance(); + AliTPCTransform *transform = calibDB->GetTransform() ; if (!transform) { AliFatal("Tranformations not in calibDB"); + return; } + 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 (!AliTPCReconstructor::GetRecoParam()->GetBYMirror()){ - if (cluster->GetDetector()%36>17){ - x[1]*=-1; - } - } + // if (cluster->GetDetector()%36>17){ + // x[1]*=-1; + //} // // in debug mode check the transformation // - if (AliTPCReconstructor::StreamLevel()>1) { + 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="<0) && (index&0x8000)==0){ + if ( (index >= 0) && (index&0x8000)==0){ cl = t.GetClusterPointer(nr); - if ( (cl==0) && (index>0)) cl = GetClusterMI(index); + if ( (cl==0) && (index >= 0)) cl = GetClusterMI(index); t.SetCurrentClusterIndex1(index); if (cl) { t.SetCurrentCluster(cl); @@ -1815,8 +1944,8 @@ Int_t AliTPCtrackerMI::FollowToNextCluster(AliTPCseed & t, Int_t nr) { } else { if (fIteration==0){ - 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.GetNumberOfClusters()>18 && ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)) t.SetRemoval(10); + if ( t.GetNumberOfClusters()>18 && t.GetChi2()/t.GetNumberOfClusters()>6 ) t.SetRemoval(10); if (( (t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) || t.GetNoCluster()>15)) t.SetRemoval(10); } @@ -1827,19 +1956,23 @@ Int_t AliTPCtrackerMI::FollowToNextCluster(AliTPCseed & t, Int_t nr) { //_____________________________________________________________________________ -Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) { +Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step, Bool_t fromSeeds) { //----------------------------------------------------------------- // This function tries to find a track prolongation. //----------------------------------------------------------------- Double_t xt=t.GetX(); // - Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift(); + Double_t alpha=t.GetAlpha(); if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); // t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN); - Int_t first = GetRowNumber(xt)-1; + Int_t first = GetRowNumber(xt); + if (!fromSeeds) + first -= step; + if (first < 0) + first = 0; for (Int_t nr= first; nr>=rf; nr-=step) { // update kink info if (t.GetKinkIndexes()[0]>0){ @@ -1878,44 +2011,27 @@ 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.SetRelativeSector(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; -} - -Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf) { +Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf, Bool_t fromSeeds) { //----------------------------------------------------------------- // This function tries to find a track prolongation. //----------------------------------------------------------------- // Double_t xt=t.GetX(); - Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift(); + Double_t alpha=t.GetAlpha(); if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN); Int_t first = t.GetFirstPoint(); - if (firstGetSigmaTglZ()+ s2->GetSigmaTglZ()); if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>thetaCut) return; @@ -2022,11 +2138,7 @@ void AliTPCtrackerMI::SignShared(AliTPCseed * s1, AliTPCseed * s2) // if ( (s1->GetClusterIndex2(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>cutN0){ // sign clusters @@ -2084,7 +2196,7 @@ void AliTPCtrackerMI::SignShared(TObjArray * arr) for (Int_t i=0; iUncheckedAt(i); if (!pt) continue; - for (Int_t j=0;j<=12;j++){ + for (Int_t j=0;j<12;j++){ pt->SetOverlapLabel(j,0); } } @@ -2140,8 +2252,11 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac // - 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(); // Int_t nseed = arr->GetEntriesFast(); @@ -2172,13 +2287,8 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac if (!pt) continue; // if (quality[trackindex]<0){ - if (pt) { delete arr->RemoveAt(trackindex); - } - else{ - arr->RemoveAt(trackindex); - } - continue; + continue; } // // @@ -2198,11 +2308,25 @@ void AliTPCtrackerMI::RemoveUsed2(TObjArray * arr, Float_t factor1, Float_t fac // 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; } @@ -2231,6 +2355,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="<GetClusterIndex2(i); + for (Int_t j=0; j<160; ++j) { + Int_t index=pt->GetClusterIndex2(j); if (index<0) continue; - AliTPCclusterMI *c= pt->GetClusterPointer(i); + AliTPCclusterMI *c= pt->GetClusterPointer(j); if (!c) continue; //if (!(c->IsUsed(10))) c->Use(); c->Use(10); @@ -2414,11 +2620,11 @@ void AliTPCtrackerMI::SignClusters(TObjArray * arr, Float_t fnumber, Float_t fde if ((dens>mindens && pt->GetNumberOfClusters()>minn) && chiGetNumberOfClusters(); pt->SetBSigned(kTRUE); - for (Int_t i=0; i<160; i++) { + 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->GetClusterPointer(i); + AliTPCclusterMI *c= pt->GetClusterPointer(j); if (!c) continue; // if (!(c->IsUsed(10))) c->Use(); c->Use(10); @@ -2433,7 +2639,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 @@ -2493,8 +2699,29 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event) // back propagation of ESD tracks // //return 0; + if (!event) return 0; const Int_t kMaxFriendTracks=2000; fEvent = event; + // extract correction object for multiplicity dependence of dEdx + TObjArray * gainCalibArray = AliTPCcalibDB::Instance()->GetTimeGainSplinesRun(event->GetRunNumber()); + + AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ; + if (!transform) { + AliFatal("Tranformations not in RefitInward"); + return 0; + } + transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam()); + const AliTPCRecoParam * recoParam = AliTPCcalibDB::Instance()->GetTransform()->GetCurrentRecoParam(); + Int_t nContribut = event->GetNumberOfTracks(); + TGraphErrors * graphMultDependenceDeDx = 0x0; + if (recoParam && recoParam->GetUseMultiplicityCorrectionDedx() && gainCalibArray) { + if (recoParam->GetUseTotCharge()) { + graphMultDependenceDeDx = (TGraphErrors *) gainCalibArray->FindObject("TGRAPHERRORS_MEANQTOT_MULTIPLICITYDEPENDENCE_BEAM_ALL"); + } else { + graphMultDependenceDeDx = (TGraphErrors *) gainCalibArray->FindObject("TGRAPHERRORS_MEANQMAX_MULTIPLICITYDEPENDENCE_BEAM_ALL"); + } + } + // ReadSeeds(event,2); fIteration=2; //PrepareForProlongation(fSeeds,1); @@ -2508,6 +2735,7 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event) 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(); @@ -2515,17 +2743,35 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *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(); - MakeBitmaps(seed); - AliESDtrack *esd=event->GetTrack(i); + AddCovariance(seed); + MakeESDBitmaps(seed, esd); seed->CookdEdx(0.02,0.6); CookLabel(seed,0.1); //For comparison only - esd->SetTPCClusterMap(seed->GetClusterMap()); - esd->SetTPCSharedMap(seed->GetSharedMap()); // - if (AliTPCReconstructor::StreamLevel()>1 && seed!=0&&esd!=0) { + if (AliTPCReconstructor::StreamLevel()>1 && seed!=0) { TTreeSRedirector &cstream = *fDebugStreamer; cstream<<"Crefit"<< "Esd.="<UpdateTrackParams(seed,AliESDtrack::kTPCrefit); esd->SetTPCPoints(seed->GetPoints()); esd->SetTPCPointsF(seed->GetNFoundable()); - Int_t ndedx = seed->GetNCDEDX(0)+seed->GetNCDEDX(1)+seed->GetNCDEDX(2)+seed->GetNCDEDX(3); - Float_t sdedx = (seed->GetSDEDX(0)+seed->GetSDEDX(1)+seed->GetSDEDX(2)+seed->GetSDEDX(3))*0.25; + Int_t ndedx = seed->GetNCDEDX(0); + Float_t sdedx = seed->GetSDEDX(0); Float_t dedx = seed->GetdEdx(); + // apply mutliplicity dependent dEdx correction if available + if (graphMultDependenceDeDx) { + Double_t corrGain = AliTPCcalibDButil::EvalGraphConst(graphMultDependenceDeDx, nContribut); + dedx += (1 - corrGain)*50.; // MIP is normalized to 50 + } esd->SetTPCsignal(dedx, sdedx, ndedx); // + // fill new dEdx information + // + Double32_t signal[4]; + Char_t ncl[3]; + Char_t nrows[3]; + // + for(Int_t iarr=0;iarr<3;iarr++) { + signal[iarr] = seed->GetDEDXregion(iarr+1); + ncl[iarr] = seed->GetNCDEDX(iarr+1); + nrows[iarr] = seed->GetNCDEDXInclThres(iarr+1); + } + signal[3] = seed->GetDEDXregion(4); + // + AliTPCdEdxInfo * infoTpcPid = new AliTPCdEdxInfo(); + infoTpcPid->SetTPCSignalRegionInfo(signal, ncl, nrows); + esd->SetTPCdEdxInfo(infoTpcPid); + // // add seed to the esd track in Calib level // Bool_t storeFriend = gRandom->Rndm()<(kMaxFriendTracks)/Float_t(nseed); @@ -2556,8 +2824,8 @@ Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event) } } //FindKinks(fSeeds,event); + if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(2,fSeeds); Info("RefitInward","Number of refitted tracks %d",ntracks); - fEvent =0; return 0; } @@ -2567,7 +2835,7 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event) // // back propagation of ESD tracks // - + if (!event) return 0; fEvent = event; fIteration = 1; ReadSeeds(event,1); @@ -2575,6 +2843,7 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event) 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(); @@ -2584,28 +2853,50 @@ Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *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 (!esd) continue; //never happen + 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->GetNFoundable()); - Int_t ndedx = seed->GetNCDEDX(0)+seed->GetNCDEDX(1)+seed->GetNCDEDX(2)+seed->GetNCDEDX(3); - Float_t sdedx = (seed->GetSDEDX(0)+seed->GetSDEDX(1)+seed->GetSDEDX(2)+seed->GetSDEDX(3))*0.25; + 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) { + 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; @@ -2629,7 +2920,7 @@ void AliTPCtrackerMI::DeleteSeeds() fSeeds =0; } -void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction) +void AliTPCtrackerMI::ReadSeeds(const AliESDEvent *const event, Int_t direction) { // //read seeds from the event @@ -2654,6 +2945,7 @@ void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction) // 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; @@ -2672,11 +2964,11 @@ void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction) } 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::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); @@ -2695,24 +2987,27 @@ void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction) // rotate to the local coordinate system // fSectors=fInnerSec; fN=fkNIS; - Double_t alpha=seed->GetAlpha() - fSectors->GetAlphaShift(); + Double_t alpha=seed->GetAlpha(); if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi(); if (alpha < 0. ) alpha += 2.*TMath::Pi(); - Int_t ns=Int_t(alpha/fSectors->GetAlpha())%fN; + Int_t ns=Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN; alpha =ns*fSectors->GetAlpha() + fSectors->GetAlphaShift(); + alpha-=seed->GetAlpha(); if (alpha<-TMath::Pi()) alpha += 2*TMath::Pi(); if (alpha>=TMath::Pi()) alpha -= 2*TMath::Pi(); - alpha-=seed->GetAlpha(); - if (!seed->Rotate(alpha)) { - delete seed; - continue; + if (TMath::Abs(alpha) > 0.001) { // This should not happen normally + AliWarning(Form("Rotating track over %f",alpha)); + if (!seed->Rotate(alpha)) { + delete seed; + continue; + } } seed->SetESD(esd); // sign clusters if (esd->GetKinkIndex(0)<=0){ for (Int_t irow=0;irow<160;irow++){ Int_t index = seed->GetClusterIndex2(irow); - if (index>0){ + if (index >= 0){ // AliTPCclusterMI * cl = GetClusterMI(index); seed->SetClusterPointer(irow,cl); @@ -2769,11 +3064,11 @@ 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); + const AliTPCtrackerRow& kr1=GetRow(ns,i1); Double_t ymax = GetMaxY(i1)-kr1.GetDeadZone()-1.5; Double_t ymaxm = GetMaxY(imiddle)-kr1.GetDeadZone()-1.5; @@ -2825,10 +3120,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); @@ -3081,25 +3376,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); + 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); // @@ -3107,7 +3402,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; // // @@ -3136,7 +3431,7 @@ void AliTPCtrackerMI::MakeSeeds5(TObjArray * arr, Int_t sec, Int_t i1, Int_t i2, y3 = kcl->GetY(); // apply angular cuts if (TMath::Abs(y1-y3)>dymax) continue; - x3 = x3; + //x3 = x3; z3 = kcl->GetZ(); if (TMath::Abs(z1-z3)>dzmax) continue; // @@ -3253,7 +3548,7 @@ 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); + index=kr1.GetIndex(is); seed->~AliTPCseed(); AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index); @@ -3302,7 +3597,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 +3626,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 +3640,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)) { @@ -3415,9 +3710,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->GetDeadZone()-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) { @@ -3566,7 +3861,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) { // // @@ -3593,7 +3888,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, if ( (indexGetX()>1){ clindex = track->GetClusterIndex2(i); - if (clindex>0){ + if (clindex >= 0){ x0[0] = trpoint->GetX(); x0[1] = trpoint->GetY(); x0[2] = trpoint->GetZ(); @@ -3604,7 +3899,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, if ( (indexGetX()>1)){ clindex = track->GetClusterIndex2(i); - if (clindex>0){ + if (clindex >= 0){ x1[0] = trpoint->GetX(); x1[1] = trpoint->GetY(); x1[2] = trpoint->GetZ(); @@ -3613,7 +3908,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, } if ( (indexGetX()>1)){ clindex = track->GetClusterIndex2(i); - if (clindex>0){ + if (clindex >= 0){ x2[0] = trpoint->GetX(); x2[1] = trpoint->GetY(); x2[2] = trpoint->GetZ(); @@ -3698,7 +3993,7 @@ AliTPCseed *AliTPCtrackerMI::MakeSeed(AliTPCseed *track, Float_t r0, Float_t r1, } -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) { // // @@ -3716,8 +4011,8 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track, Float_t r0, Float_t r1, F ipos[2] = TMath::Min(int(r2*nclusters),nclusters-1); // last point // // - Double_t xyz[3][3]; - Int_t row[3],sec[3]={0,0,0}; + Double_t xyz[3][3]={{0}}; + Int_t row[3]={0},sec[3]={0,0,0}; // // find track row position at given ratio of the length Int_t index=-1; @@ -3965,7 +4260,7 @@ AliTPCseed *AliTPCtrackerMI::ReSeed(AliTPCseed *track,Int_t r0, Bool_t forward) -void AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_t iter) +void AliTPCtrackerMI::FindMultiMC(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter) { // // find multi tracks - THIS FUNCTION IS ONLY FOR DEBUG PURPOSES @@ -4034,7 +4329,6 @@ void AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_ } if (ncl>0) xm[i]/=Float_t(ncl); } - TTreeSRedirector &cstream = *fDebugStreamer; // for (Int_t i0=0;i0At(i0); @@ -4095,6 +4389,8 @@ void AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_ } } // + if (AliTPCReconstructor::StreamLevel()>5) { + TTreeSRedirector &cstream = *fDebugStreamer; cstream<<"Multi"<< "iter="<1) { AliInfo("Time for curling tracks removal DEBUGGING MC"); timer.Print(); @@ -4141,44 +4440,38 @@ void AliTPCtrackerMI::FindMultiMC(TObjArray * array, AliESDEvent */*esd*/, Int_ } -void AliTPCtrackerMI::FindSplitted(TObjArray * array, AliESDEvent */*esd*/, Int_t iter) -{ - // - // - // 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 - // - // This function tries to find tracks closed in the parametric space - // - // cut logic if distance is bigger than cut continue - Do Nothing - const Float_t kMaxdTheta = 0.05; // maximal distance in theta - const Float_t kMaxdPhi = 0.05; // maximal deistance in phi - const Float_t kdelta = 40.; //delta r to calculate track distance - // - // const Float_t kMaxDist0 = 1.; // maximal distance 0 - //const Float_t kMaxDist1 = 0.3; // maximal distance 1 - cut if track in separate rows - // - /* - TCut csec("csec","abs(Tr0.fRelativeSector-Tr1.fRelativeSector)<2"); - TCut cdtheta("cdtheta","abs(dtheta)<0.05"); - */ - // + +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(); - AliHelix *helixes = new AliHelix[nentries]; - Float_t *xm = new Float_t[nentries]; + AliExternalTrackParam *params = new AliExternalTrackParam[nentries]; // // TStopwatch timer; timer.Start(); // - //Sort tracks according quality - // + //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; iGetNumberOfClusters(); //prefer high momenta tracks if overlaps - quality[i] *= TMath::Sqrt(TMath::Abs(pt->Pt())+0.5); + 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); - - - // - // 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; - 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); - } - TTreeSRedirector &cstream = *fDebugStreamer; // - for (Int_t is0=0;is0At(i0); - if (!track0) continue; - if (track0->GetKinkIndexes()[0]!=0) continue; - Float_t xc0 = helixes[i0].GetHelix(6); - Float_t yc0 = helixes[i0].GetHelix(7); - Float_t fi0 = TMath::ATan2(yc0,xc0); - - for (Int_t is1=is0+1;is1At(i1); - if (!track1) continue; + // 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; // - if (TMath::Abs(track0->GetRelativeSector()-track1->GetRelativeSector())>1) continue; - if (track1->GetKinkIndexes()[0]>0 &&track0->GetKinkIndexes()[0]<0) continue; - if (track1->GetKinkIndexes()[0]!=0) continue; - - Float_t dtheta = TMath::Abs(track0->GetTgl()-track1->GetTgl())GetTgl()+track1->GetTgl())? track0->GetTgl()-track1->GetTgl():track0->GetTgl()+track1->GetTgl(); - if (TMath::Abs(dtheta)>kMaxdTheta) 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; // - Float_t xc1 = helixes[i1].GetHelix(6); - Float_t yc1 = helixes[i1].GetHelix(7); - 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; + 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="<kMaxdPhi) continue; - // - // - Float_t sum =0; - Float_t sums=0; - Float_t sum0=0; - Float_t sum1=0; - for (Int_t icl=0; icl<160; icl++){ - Int_t index0=track0->GetClusterIndex2(icl); - Int_t index1=track1->GetClusterIndex2(icl); - Bool_t used0 = (index0>0 && !(index0&0x8000)); - Bool_t used1 = (index1>0 && !(index1&0x8000)); - // - if (used0) sum0++; // used cluster0 - if (used1) sum1++; // used clusters1 - if (used0&&used1) sum++; - if (index0==index1 && used0 && used1) sums++; - } - - // - if (sums<10) continue; - if (sum<40) continue; - if (sums/Float_t(TMath::Min(sum0,sum1))<0.5) continue; - // - Double_t dist[5][4]; // distance at X - Double_t mdist[4]={0,0,0,0}; // mean distance on range +-delta - - // - // - track0->GetDistance(track1,xm[i0],dist[0],AliTracker::GetBz()); - for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[0][i]); - track0->GetDistance(track1,xm[i1],dist[1],AliTracker::GetBz()); - for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[1][i]); - // - track0->GetDistance(track1,TMath::Min(xm[i1],xm[i0])-kdelta,dist[2],AliTracker::GetBz()); - for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[2][i]); - track0->GetDistance(track1,TMath::Max(xm[i1],xm[i0])+kdelta,dist[3],AliTracker::GetBz()); - for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[3][i]); - // - track0->GetDistance(track1,(xm[i1]+xm[i0])*0.5,dist[4],AliTracker::GetBz()); - for (Int_t i=0;i<3;i++) mdist[i]+=TMath::Abs(dist[4][i]); - for (Int_t i=0;i<3;i++) mdist[i]*=0.2; // + // remove track with lower quality // - Int_t lab0=track0->GetLabel(); - Int_t lab1=track1->GetLabel(); - cstream<<"Splitted"<< - "iter="<RemoveAt(i1); + delete array->RemoveAt(index1); + } } - } - delete [] helixes; - delete [] xm; - AliInfo("Time for splitted tracks removal"); - timer.Print(); + } + // + // 4. Delete temporary array + // + delete [] params; + delete [] quality; + delete [] indexes; + } -void AliTPCtrackerMI::FindCurling(TObjArray * array, AliESDEvent */*esd*/, Int_t iter) +void AliTPCtrackerMI::FindCurling(const TObjArray * array, AliESDEvent */*esd*/, Int_t iter) { // // find Curling tracks @@ -4398,11 +4655,11 @@ void AliTPCtrackerMI::FindCurling(TObjArray * array, AliESDEvent */*esd*/, Int_ // TStopwatch timer; timer.Start(); - Double_t phase[2][2],radius[2]; + Double_t phase[2][2]={{0,0},{0,0}},radius[2]={0,0}; + // // Find tracks // - TTreeSRedirector &cstream = *fDebugStreamer; // for (Int_t i0=0;i0At(i0); @@ -4495,11 +4752,12 @@ void AliTPCtrackerMI::FindCurling(TObjArray * array, AliESDEvent */*esd*/, Int_ track0->SetCircular(track0->GetCircular()+2); } } - if (AliTPCReconstructor::StreamLevel()>1){ + 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="<GetKinkAngleCutChi2(0)){ + continue; + } + // kinks->AddLast(kink); kink = new AliKink; ncandidates++; @@ -4948,12 +5230,12 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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); // @@ -4961,10 +5243,10 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) // // 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; @@ -4979,9 +5261,9 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) 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()); + 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; @@ -4992,7 +5274,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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; @@ -5003,7 +5285,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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); // @@ -5013,7 +5295,8 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]); if (!kink0) continue; // - for (Int_t ikink1=0;ikink1At(indexes[ikink0]); if (!kink0) continue; AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]); if (!kink1) continue; @@ -5066,6 +5349,7 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) shared[kink0->GetIndex(0)]= kTRUE; shared[kink0->GetIndex(1)]= kTRUE; delete kinks->RemoveAt(indexes[ikink0]); + break; } else{ shared[kink1->GetIndex(0)]= kTRUE; @@ -5078,23 +5362,23 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink @@ -5135,15 +5419,15 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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->GetFirstPoint();iclGetLastPoint(); icl++){ if (track0->GetClusterPointer(icl)!=0){ all++; - if (track0->GetClusterPointer(icl)->IsUsed(10)) shared++; + if (track0->GetClusterPointer(icl)->IsUsed(10)) ishared++; } } - if (Float_t(shared+1)/Float_t(all+1)>0.5) { + if (Float_t(ishared+1)/Float_t(all+1)>0.5) { delete array->RemoveAt(i); continue; } @@ -5157,8 +5441,8 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd) AliTPCseed & mother = *pmother; AliTPCseed & daughter = *pdaughter; - AliKink & kink = *pkink; - if (CheckKinkPoint(track0,mother,daughter, kink)){ + AliKink & kinkl = *pkink; + if (CheckKinkPoint(track0,mother,daughter, kinkl)){ if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) { delete pmother; delete pdaughter; @@ -5171,15 +5455,15 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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); + Int_t index = esd->AddKink(&kinkl); mother.SetKinkIndex(0,-(index+1)); daughter.SetKinkIndex(0,index+1); if (mother.GetNumberOfClusters()>50) { @@ -5226,367 +5510,12 @@ void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *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, AliESDEvent *esd) -{ - // - // find V0s - // - // - TObjArray *tpcv0s = new TObjArray(100000); - Int_t nentries = array->GetEntriesFast(); - AliHelix *helixes = new AliHelix[nentries]; - Int_t *sign = new Int_t[nentries]; - Float_t *alpha = new Float_t[nentries]; - Float_t *z0 = new Float_t[nentries]; - Float_t *dca = new Float_t[nentries]; - Float_t *sdcar = new Float_t[nentries]; - Float_t *cdcar = new Float_t[nentries]; - Float_t *pulldcar = new Float_t[nentries]; - Float_t *pulldcaz = new Float_t[nentries]; - Float_t *pulldca = new Float_t[nentries]; - Bool_t *isPrim = new Bool_t[nentries]; - const AliESDVertex * primvertex = esd->GetVertex(); - Double_t zvertex = primvertex->GetZv(); - // - // nentries = array->GetEntriesFast(); - // - for (Int_t i=0;iAt(i); - if (!track) continue; - track->GetV0Indexes()[0] = 0; //rest v0 indexes - track->GetV0Indexes()[1] = 0; //rest v0 indexes - track->GetV0Indexes()[2] = 0; //rest v0 indexes - // - alpha[i] = track->GetAlpha(); - new (&helixes[i]) AliHelix(*track); - Double_t xyz[3]; - helixes[i].Evaluate(0,xyz); - sign[i] = (track->GetC()>0) ? -1:1; - Double_t x,y,z; - x=160; - z0[i]=1000; - if (track->GetProlongation(0,y,z)) z0[i] = z; - dca[i] = track->GetD(0,0); - // - // dca error parrameterezation + pulls - // - 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->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->TPCrPID(4)>0.5) { - if (pulldca[i]<0.5) isPrim[i]=kTRUE; //proton 0.5 sigma cut - } - if (track->TPCrPID(0)>0.4) { - isPrim[i]=kFALSE; //electron no sigma cut - } - } - // - // - TStopwatch timer; - timer.Start(); - Int_t ncandidates =0; - Int_t nall =0; - Int_t ntracks=0; - Double_t phase[2][2],radius[2]; - // - // Finf V0s loop - // - // - // // - TTreeSRedirector &cstream = *fDebugStreamer; - Float_t fprimvertex[3]={GetX(),GetY(),GetZ()}; - AliV0 vertex; - Double_t cradius0 = 10*10; - Double_t cradius1 = 200*200; - Double_t cdist1=3.; - Double_t cdist2=4.; - Double_t cpointAngle = 0.95; - // - Double_t delta[2]={10000,10000}; - for (Int_t i =0;iAt(i); - if (!track0) continue; - if (AliTPCReconstructor::StreamLevel()>1){ - cstream<<"Tracks"<< - "Tr0.="<GetSigned1Pt()<0) continue; - if (track0->GetKinkIndex(0)>0||isPrim[i]) continue; //daughter kink - // - if (TMath::Abs(helixes[i].GetHelix(4))<0.000000001) continue; - ntracks++; - // debug output - - - for (Int_t j =0;jAt(j); - if (!track1) continue; - 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->GetCircular()+track1->GetCircular()>1) continue; //circling -returning track - nall++; - // - // DCA to prim vertex cut - // - // - delta[0]=10000; - delta[1]=10000; - - Int_t npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,cdist2); - if (npoints<1) continue; - Int_t iclosest=0; - // cuts on radius - if (npoints==1){ - if (radius[0]cradius1) continue; - helixes[i].LinearDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta[0]); - if (delta[0]>cdist1) continue; - } - else{ - if (TMath::Max(radius[0],radius[1])cradius1) continue; - helixes[i].LinearDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta[0]); - helixes[i].LinearDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta[1]); - if (delta[1]cdist1) continue; - } - helixes[i].ParabolicDCA(helixes[j],phase[iclosest][0],phase[iclosest][1],radius[iclosest],delta[iclosest]); - if (radius[iclosest]cradius1 || delta[iclosest]>cdist1) continue; - // - Double_t pointAngle = helixes[i].GetPointAngle(helixes[j],phase[iclosest],fprimvertex); - if (pointAngleTPCrPID(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.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); - //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){ - //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 - densa0 = track0->Density2(row0+5,row0+40); - densa1 = track1->Density2(row0+5,row0+40); - if ((densa0<0.4|| densa1<0.4)&&(!isGamma)) continue; //missing clusters after vertex - } - else{ - densa0 = track0->Density2(0,40); //cluster density - densa1 = track1->Density2(0,40); //cluster density - if ((vertex.GetRr()<80&&densa0+densa1<1.)&&(!isGamma)) continue; - } -//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); -//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->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(); - cstream<<"V0"<< - "Event="<At(i); - quality[i] = 1./(1.00001-v0->GetV0CosineOfPointingAngle()); //base point angle - // quality[i] /= (0.5+v0->GetDist2()); - // quality[i] *= v0->GetChi2After(); //density factor - - 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->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]); - if (!v0) continue; - Int_t index0 = v0->GetIndex(0); - Int_t index1 = v0->GetIndex(1); - AliTPCseed * track0 = (AliTPCseed*)array->At(index0); - AliTPCseed * track1 = (AliTPCseed*)array->At(index1); - if (!track0||!track1) { - printf("Bug\n"); - continue; - } - Bool_t accept =kTRUE; //default accept - Int_t *v0indexes0 = track0->GetV0Indexes(); - Int_t *v0indexes1 = track1->GetV0Indexes(); - // - Int_t order0 = (v0indexes0[0]!=0) ? 1:0; - Int_t order1 = (v0indexes1[0]!=0) ? 1:0; - if (v0indexes0[1]!=0) order0 =2; - if (v0indexes1[1]!=0) order1 =2; - // - if (v0indexes0[2]!=0) {order0=3; accept=kFALSE;} - if (v0indexes0[2]!=0) {order1=3; accept=kFALSE;} - // - AliESDv0 * v02 = v0; - if (accept){ - //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->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(); - cstream<<"V02"<< - "Event="<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); @@ -5874,9 +5828,12 @@ Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTP daughter = param1[index]; daughter.SetLabel(kink.GetLabel(1)); param0[index].Reset(kTRUE); - FollowProlongation(param0[index],0); + FollowProlongation(param0[index],0); mother = param0[index]; mother.SetLabel(kink.GetLabel(0)); + if ( chi2P2+chi2P3GetKinkAngleCutChi2(1)){ + mother=*seed; + } delete seed0; delete seed1; // @@ -5951,14 +5908,22 @@ Int_t AliTPCtrackerMI::ReadSeeds(const TFile *inp) { return 0; } -Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *esd) +Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *const esd) { // + // clusters to tracks + if (fSeeds) DeleteSeeds(); - fEvent = esd; + fEvent = esd; + + AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ; + transform->SetCurrentTimeStamp( esd->GetTimeStamp()); + transform->SetCurrentRun(esd->GetRunNumber()); + Clusters2Tracks(); if (!fSeeds) return 1; FillESD(fSeeds); + if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(0,fSeeds); return 0; // } @@ -5990,7 +5955,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { CookLabel(pt,0.1); 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 + pt->Desactivate(10); // make track again active // MvL: should be 0 ? else{ pt->Desactivate(20); delete fSeeds->RemoveAt(i); @@ -6001,9 +5966,10 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { RemoveUsed2(fSeeds,0.85,0.85,0); if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent); //FindCurling(fSeeds, fEvent,0); - if (AliTPCReconstructor::StreamLevel()>2) FindMultiMC(fSeeds, fEvent,0); // find multi found tracks + 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 @@ -6081,7 +6047,7 @@ Int_t AliTPCtrackerMI::Clusters2Tracks() { fIteration = 2; PrepareForProlongation(fSeeds,5.); - PropagateForward2(fSeeds); + PropagateForard2(fSeeds); printf("Time for FORWARD propagation: \t");timer.Print();timer.Start(); // RemoveUsed(fSeeds,0.7,0.7,6); @@ -6164,7 +6130,7 @@ TObjArray * AliTPCtrackerMI::Tracking(Int_t seedtype, Int_t i1, Int_t i2, Float_ TObjArray * AliTPCtrackerMI::Tracking() { - // + // tracking // if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial(); TStopwatch timer; @@ -6173,6 +6139,9 @@ TObjArray * AliTPCtrackerMI::Tracking() 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]; @@ -6186,7 +6155,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; @@ -6211,7 +6180,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; @@ -6264,9 +6233,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; @@ -6289,10 +6271,9 @@ TObjArray * AliTPCtrackerMI::Tracking() fdensity = 2.; cuts[0]=0.0080; - Int_t fLastSeedRowSec=AliTPCReconstructor::GetRecoParam()->GetLastSeedRowSec(); // find secondaries - for (Int_t delta = 30; deltaGetNRowLow()>rfirst+1) ) + if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fkParam->GetNRowLow()>rfirst+1) ) FollowProlongation(t, rfirst+1); } @@ -6438,7 +6419,7 @@ 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())fFirstPoint-fkParam->GetNRowLow())GetRelativeSector()>17) { continue; } @@ -6449,7 +6430,7 @@ 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())fFirstPoint-fkParam->GetNRowLow())GetRelativeSector()>17) { continue; } @@ -6458,7 +6439,7 @@ void AliTPCtrackerMI::ParallelTracking(TObjArray * arr, Int_t rfirst, Int_t rla } } -void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) const +void AliTPCtrackerMI::PrepareForBackProlongation(const TObjArray *const arr,Float_t fac) const { // // @@ -6480,7 +6461,7 @@ void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray * arr,Float_t fac) co Float_t angle2 = pt->GetAlpha(); if (TMath::Abs(angle1-angle2)>0.001){ - pt->Rotate(angle1-angle2); + if (!pt->Rotate(angle1-angle2)) return; //angle2 = pt->GetAlpha(); //pt->fRelativeSector = pt->GetAlpha()/fInnerSec->GetAlpha(); //if (pt->GetAlpha()<0) @@ -6494,7 +6475,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 { // // @@ -6513,7 +6494,7 @@ void AliTPCtrackerMI::PrepareForProlongation(TObjArray * arr, Float_t fac) const } -Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) +Int_t AliTPCtrackerMI::PropagateBack(const TObjArray *const arr) { // // make back propagation @@ -6526,7 +6507,7 @@ Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) fSectors = fInnerSec; //FollowBackProlongation(*pt,fInnerSec->GetNRows()-1); //fSectors = fOuterSec; - FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1); + FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1); //if (pt->GetNumberOfClusters()<(pt->fEsd->GetTPCclusters(0)) ){ // Error("PropagateBack","Not prolonged track %d",pt->GetLabel()); // FollowBackProlongation(*pt2,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1); @@ -6536,7 +6517,7 @@ Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) AliESDkink * kink = fEvent->GetKink(pt->GetKinkIndex(0)-1); pt->SetFirstPoint(kink->GetTPCRow0()); fSectors = fInnerSec; - FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1); + FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1); } CookLabel(pt,0.3); } @@ -6544,7 +6525,7 @@ Int_t AliTPCtrackerMI::PropagateBack(TObjArray * arr) } -Int_t AliTPCtrackerMI::PropagateForward2(TObjArray * arr) +Int_t AliTPCtrackerMI::PropagateForward2(const TObjArray *const arr) { // // make forward propagation @@ -6554,12 +6535,12 @@ Int_t AliTPCtrackerMI::PropagateForward2(TObjArray * arr) for (Int_t i=0;iUncheckedAt(i); if (pt) { - FollowProlongation(*pt,0); + FollowProlongation(*pt,0,1,1); CookLabel(pt,0.3); } } - return 0; + return 0; } @@ -6592,7 +6573,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 @@ -6626,27 +6607,32 @@ Int_t AliTPCtrackerMI::PropagateBack(AliTPCseed * pt, Int_t row0, Int_t row1) void AliTPCtrackerMI::GetShape(AliTPCseed * seed, Int_t row) { - // + // gets cluster shape // AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam(); - Float_t zdrift = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ()))); - Int_t type = (seed->GetSector() < fParam->GetNSector()/2) ? 0: (row>126) ? 1:2; + 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*angulary); + + if (TMath::Abs(angulary)>AliTPCReconstructor::GetMaxSnpTracker()) { + angulary = TMath::Sign(AliTPCReconstructor::GetMaxSnpTracker(),angulary); + } + + 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((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL(); -// // Float_t padlength = fParam->GetPadPitchLength(seed->fSector); + // 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() < fParam->GetNSector()/2) ? 0.2 :0.3; +// Float_t sresy = (seed->GetSector() < fkParam->GetNSector()/2) ? 0.2 :0.3; // seed->SetCurrentSigmaY2(sd2+padlength*padlength*angulary/12.+sresy*sresy); // // -// Float_t sresz = fParam->GetZSigma(); +// Float_t sresz = fkParam->GetZSigma(); // seed->SetCurrentSigmaZ2(sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz); /* Float_t wy = GetSigmaY(seed); @@ -6723,14 +6709,14 @@ 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); max=0; Int_t ind=0; - for (i=1; i<=160&&indGetLabel(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); max=0; Int_t ind=0; - for (i=1; i<=160&&ind 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(); - if(fRow)delete [] fRow;fRow = 0; - fRow=new AliTPCRow[fN]; - for (Int_t i=0; iGetPadRowRadiiLow(i)); - fRow[i].SetDeadZone(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(); - if(fRow)delete [] fRow;fRow = 0; - fRow=new AliTPCRow[fN]; - for (Int_t i=0; iGetPadRowRadiiUp(i)); - fRow[i].SetDeadZone(1.5); // 1.5 cm of dead zone - } - } -} - -AliTPCtrackerMI::AliTPCRow::AliTPCRow(): - fDeadZone(0.), - fClusters1(0), - fN1(0), - fClusters2(0), - fN2(0), - fN(0), - fX(0.) -{ - // - // default constructor - // -} - -AliTPCtrackerMI::AliTPCRow::~AliTPCRow(){ - // - for (Int_t i = 0; i < fN1; i++) - fClusters1[i].~AliTPCclusterMI(); - delete [] fClusters1; - for (Int_t i = 0; i < fN2; i++) - fClusters2[i].~AliTPCclusterMI(); - delete [] fClusters2; -} - -//_________________________________________________________________________ -void -AliTPCtrackerMI::AliTPCRow::InsertCluster(const AliTPCclusterMI* c, UInt_t index) { +void AliTPCtrackerMI::MakeESDBitmaps(AliTPCseed *t, AliESDtrack *esd) +{ //----------------------------------------------------------------------- - // Insert a cluster into this pad row in accordence with its y-coordinate + // Fill the cluster and sharing bitmaps of the track //----------------------------------------------------------------------- - if (fN==kMaxClusterPerRow) { - //AliInfo("AliTPCRow::InsertCluster(): Too many clusters"); - return; - } - if (fN>=fN1+fN2) { - //AliInfo("AliTPCRow::InsertCluster(): Too many clusters !"); - } - 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++; -} + Int_t firstpoint = 0; + Int_t lastpoint = 159; + AliTPCTrackerPoint *point; + AliTPCclusterMI *cluster; + + Int_t nclsf = 0; + TBits clusterMap(159); + TBits sharedMap(159); + TBits fitMap(159); + for (int iter=firstpoint; iterGetClusterPointer(iter); + if (cluster) { + clusterMap.SetBitNumber(iter, kTRUE); + point = t->GetTrackPoint(iter); + if (point->IsShared()) + sharedMap.SetBitNumber(iter,kTRUE); + } + if (t->GetClusterIndex(iter) >= 0 && (t->GetClusterIndex(iter) & 0x8000) == 0) { + fitMap.SetBitNumber(iter, kTRUE); + nclsf++; + } + } + esd->SetTPCClusterMap(clusterMap); + esd->SetTPCSharedMap(sharedMap); + esd->SetTPCFitMap(fitMap); + if (nclsf != t->GetNumberOfClusters()) + AliWarning(Form("Inconsistency between ncls %d and indices %d (found %d)",t->GetNumberOfClusters(),nclsf,esd->GetTPCClusterMap().CountBits())); } - -//___________________________________________________________________ -Int_t AliTPCtrackerMI::AliTPCRow::Find(Double_t z) const { - //----------------------------------------------------------------------- - // Return the index of the nearest cluster - //----------------------------------------------------------------------- - 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; +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; - Float_t distance = (c->GetZ()-z)*(c->GetZ()-z)+(c->GetY()-y)*(c->GetY()-y); - if (maxdistance>distance) { - maxdistance = distance; - cl=c; - } - } - 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(GetFastCluster(iz1)-1,0); - Int_t iz2 = Int_t(z+roadz+255.5); - if (iz2<0 || iz2>=510) return cl; - iz2 = TMath::Min(GetFastCluster(iz2)+1,fN); - Bool_t skipUsed = !(AliTPCReconstructor::GetRecoParam()->GetClusterSharing()); - //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; - if (skipUsed && c->IsUsed(11)) 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); - } +void AliTPCtrackerMI::AddCovariance(AliTPCseed * seed){ + // + // Adding systematic error estimate to the covariance matrix + // !!!! the systematic error for element 4 is in 1/cm not in pt + // + const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError(); + // + // use only the diagonal part if not specified otherwise + if (!AliTPCReconstructor::GetRecoParam()->GetUseSystematicCorrelation()) return AddCovarianceAdd(seed); + // + Double_t *covarS= (Double_t*)seed->GetCovariance(); + Double_t factor[5]={1,1,1,1,1}; + Double_t facC = AliTracker::GetBz()*kB2C; + factor[0]= TMath::Sqrt(TMath::Abs((covarS[0] + param[0]*param[0])/covarS[0])); + factor[1]= TMath::Sqrt(TMath::Abs((covarS[2] + param[1]*param[1])/covarS[2])); + factor[2]= TMath::Sqrt(TMath::Abs((covarS[5] + param[2]*param[2])/covarS[5])); + factor[3]= TMath::Sqrt(TMath::Abs((covarS[9] + param[3]*param[3])/covarS[9])); + factor[4]= TMath::Sqrt(TMath::Abs((covarS[14] + facC*facC*param[4]*param[4])/covarS[14])); + // 0 + // 1 2 + // 3 4 5 + // 6 7 8 9 + // 10 11 12 13 14 + for (Int_t i=0; i<5; i++){ + for (Int_t j=i; j<5; j++){ + Int_t index=seed->GetIndex(i,j); + covarS[index]*=factor[i]*factor[j]; + } } - return cl; } -void AliTPCtrackerMI::AliTPCRow::SetFastCluster(Int_t i, Short_t cl){ +void AliTPCtrackerMI::AddCovarianceAdd(AliTPCseed * seed){ // - // Set cluster info for fast navigation + // Adding systematic error - as additive factor without correlation // - if (i>510|| i<0){ - }else{ - fFastCluster[i]=cl; - } -} - - - - -void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t) -{ - //----------------------------------------------------------------------- - // Fill the cluster and sharing bitmaps of the track - //----------------------------------------------------------------------- - - Int_t firstpoint = 0; - Int_t lastpoint = 159; - AliTPCTrackerPoint *point; - - for (int iter=firstpoint; iterGetTrackPoint(iter); - if (point) { - t->SetClusterMapBit(iter, kTRUE); - if (point->IsShared()) - t->SetSharedMapBit(iter,kTRUE); - else - t->SetSharedMapBit(iter, kFALSE); - } - else { - t->SetClusterMapBit(iter, kFALSE); - t->SetSharedMapBit(iter, kFALSE); - } - } + 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); }