//
// Origin: Marian Ivanov Marian.Ivanov@cern.ch
//
-// AliTPC parallel tracker -
-// How to use? -
-// run AliTPCFindClusters.C macro - clusters neccessary for tracker are founded
-// run AliTPCFindTracksMI.C macro - to find tracks
-// tracks are written to AliTPCtracks.root file
-// for comparison also seeds are written to the same file - to special branch
+// AliTPC parallel tracker
//-------------------------------------------------------
#include <TFile.h>
#include <TObjArray.h>
#include <TTree.h>
+#include "AliLog.h"
#include "AliComplexCluster.h"
#include "AliESD.h"
-#include "AliESDkink.h"
+#include "AliKink.h"
+#include "AliV0.h"
#include "AliHelix.h"
#include "AliRunLoader.h"
#include "AliTPCClustersRow.h"
#include "AliTPCParam.h"
#include "AliTPCReconstructor.h"
-#include "AliTPCclusterMI.h"
#include "AliTPCpolyTrack.h"
#include "AliTPCreco.h"
#include "AliTPCseed.h"
#include "AliTPCtrackerMI.h"
#include "TStopwatch.h"
#include "AliTPCReconstructor.h"
-#include "AliESDkink.h"
#include "AliPID.h"
#include "TTreeStream.h"
+#include "AliAlignObj.h"
+#include "AliTrackPointArray.h"
+
//
ClassImp(AliTPCtrackerMI)
Int_t index = int(x*10000);
return -(fgFastAsin[2*index]+(x*10000.-index)*fgFastAsin[2*index+1]);
}
-
+//__________________________________________________________________
+AliTPCtrackerMI::AliTPCtrackerMI()
+ :AliTracker(),
+ fkNIS(0),
+ fInnerSec(0),
+ fkNOS(0),
+ fOuterSec(0),
+ fN(0),
+ fSectors(0),
+ fInput(0),
+ fOutput(0),
+ fSeedTree(0),
+ fTreeDebug(0),
+ fEvent(0),
+ fDebug(0),
+ fNewIO(kFALSE),
+ fNtracks(0),
+ fSeeds(0),
+ fIteration(0),
+ fParam(0),
+ fDebugStreamer(0)
+{
+ //
+ // default constructor
+ //
+}
+//_____________________________________________________________________
//update track information using current cluster - track->fCurrentCluster
- AliTPCclusterMI* c =track->fCurrentCluster;
- if (accept>0) track->fCurrentClusterIndex1 |=0x8000; //sign not accepted clusters
+ AliTPCclusterMI* c =track->GetCurrentCluster();
+ if (accept>0) track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000); //sign not accepted clusters
- UInt_t i = track->fCurrentClusterIndex1;
+ UInt_t i = track->GetCurrentClusterIndex1();
Int_t sec=(i&0xff000000)>>24;
//Int_t row = (i&0x00ff0000)>>16;
- track->fRow=(i&0x00ff0000)>>16;
- track->fSector = sec;
+ track->SetRow((i&0x00ff0000)>>16);
+ track->SetSector(sec);
// Int_t index = i&0xFFFF;
- if (sec>=fParam->GetNInnerSector()) track->fRow += fParam->GetNRowLow();
- track->SetClusterIndex2(track->fRow, i);
+ if (sec>=fParam->GetNInnerSector()) track->SetRow(track->GetRow()+fParam->GetNRowLow());
+ track->SetClusterIndex2(track->GetRow(), i);
//track->fFirstPoint = row;
//if ( track->fLastPoint<row) track->fLastPoint =row;
// if (track->fRow<0 || track->fRow>160) {
// printf("problem\n");
//}
- if (track->fFirstPoint>track->fRow)
- track->fFirstPoint = track->fRow;
- if (track->fLastPoint<track->fRow)
- track->fLastPoint = track->fRow;
+ if (track->GetFirstPoint()>track->GetRow())
+ track->SetFirstPoint(track->GetRow());
+ if (track->GetLastPoint()<track->GetRow())
+ track->SetLastPoint(track->GetRow());
- track->fClusterPointer[track->fRow] = c;
+ track->SetClusterPointer(track->GetRow(),c);
//
- Float_t angle2 = track->GetSnp()*track->GetSnp();
- angle2 = TMath::Sqrt(angle2/(1-angle2));
+ Double_t angle2 = track->GetSnp()*track->GetSnp();
//
//SET NEW Track Point
//
- // if (debug)
+ if (angle2<1) //PH sometimes angle2 is very big. To be investigated...
{
- AliTPCTrackerPoint &point =*(track->GetTrackPoint(track->fRow));
+ angle2 = TMath::Sqrt(angle2/(1-angle2));
+ AliTPCTrackerPoint &point =*(track->GetTrackPoint(track->GetRow()));
//
- point.SetSigmaY(c->GetSigmaY2()/track->fCurrentSigmaY2);
- point.SetSigmaZ(c->GetSigmaZ2()/track->fCurrentSigmaZ2);
- point.SetErrY(sqrt(track->fErrorY2));
- point.SetErrZ(sqrt(track->fErrorZ2));
+ point.SetSigmaY(c->GetSigmaY2()/track->GetCurrentSigmaY2());
+ point.SetSigmaZ(c->GetSigmaZ2()/track->GetCurrentSigmaZ2());
+ point.SetErrY(sqrt(track->GetErrorY2()));
+ point.SetErrZ(sqrt(track->GetErrorZ2()));
//
point.SetX(track->GetX());
point.SetY(track->GetY());
point.SetZ(track->GetZ());
point.SetAngleY(angle2);
point.SetAngleZ(track->GetTgl());
- if (point.fIsShared){
- track->fErrorY2 *= 4;
- track->fErrorZ2 *= 4;
+ if (point.IsShared()){
+ track->SetErrorY2(track->GetErrorY2()*4);
+ track->SetErrorZ2(track->GetErrorZ2()*4);
}
}
- Double_t chi2 = track->GetPredictedChi2(track->fCurrentCluster);
+ Double_t chi2 = track->GetPredictedChi2(track->GetCurrentCluster());
//
- track->fErrorY2 *= 1.3;
- track->fErrorY2 += 0.01;
- track->fErrorZ2 *= 1.3;
- track->fErrorZ2 += 0.005;
+ track->SetErrorY2(track->GetErrorY2()*1.3);
+ track->SetErrorY2(track->GetErrorY2()+0.01);
+ track->SetErrorZ2(track->GetErrorZ2()*1.3);
+ track->SetErrorZ2(track->GetErrorZ2()+0.005);
//}
if (accept>0) return 0;
if (track->GetNumberOfClusters()%20==0){
// new(larr[ihelix]) AliHelix(*track) ;
//}
}
- track->fNoCluster =0;
+ track->SetNoCluster(0);
return track->Update(c,chi2,i);
}
Double_t sdistancey2 = sy2+seed->GetSigmaY2();
Double_t sdistancez2 = sz2+seed->GetSigmaZ2();
- Double_t rdistancey2 = (seed->fCurrentCluster->GetY()-seed->GetY())*
- (seed->fCurrentCluster->GetY()-seed->GetY())/sdistancey2;
- Double_t rdistancez2 = (seed->fCurrentCluster->GetZ()-seed->GetZ())*
- (seed->fCurrentCluster->GetZ()-seed->GetZ())/sdistancez2;
+ Double_t 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 rdistance2 = rdistancey2+rdistancez2;
//Int_t accept =0;
if ( (rdistancey2>1.*factor || rdistancez2>6.25*factor )
&& cluster->GetType()<0){
- seed->fNFoundable--;
+ seed->SetNFoundable(seed->GetNFoundable()-1);
return 2;
}
return 0;
//_____________________________________________________________________________
AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCParam *par):
-AliTracker(), fkNIS(par->GetNInnerSector()/2), fkNOS(par->GetNOuterSector()/2)
+AliTracker(),
+ fkNIS(par->GetNInnerSector()/2),
+ fInnerSec(0),
+ fkNOS(par->GetNOuterSector()/2),
+ fOuterSec(0),
+ fN(0),
+ fSectors(0),
+ fInput(0),
+ fOutput(0),
+ fSeedTree(0),
+ fTreeDebug(0),
+ fEvent(0),
+ fDebug(0),
+ fNewIO(0),
+ fNtracks(0),
+ fSeeds(0),
+ fIteration(0),
+ fParam(0),
+ fDebugStreamer(0)
{
//---------------------------------------------------------------------
// The main TPC tracker constructor
for (i=0; i<fkNIS; i++) fInnerSec[i].Setup(par,0);
for (i=0; i<fkNOS; i++) fOuterSec[i].Setup(par,1);
- fN=0; fSectors=0;
-
- fSeeds=0;
- fNtracks = 0;
fParam = par;
Int_t nrowlow = par->GetNRowLow();
Int_t nrowup = par->GetNRowUp();
fPadLength[i+nrowlow] = par->GetPadPitchLength(60,i);
fYMax[i+nrowlow] = fXRow[i+nrowlow]*TMath::Tan(0.5*par->GetOuterAngle());
}
- fSeeds=0;
- //
- fInput = 0;
- fOutput = 0;
- fSeedTree = 0;
- fTreeDebug =0;
- fNewIO =0;
- fDebug =0;
- fEvent =0;
+
fDebugStreamer = new TTreeSRedirector("TPCdebug.root");
}
//________________________________________________________________________
AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
AliTracker(t),
- fkNIS(t.fkNIS),
- fkNOS(t.fkNOS)
+ fkNIS(t.fkNIS),
+ fInnerSec(0),
+ fkNOS(t.fkNOS),
+ fOuterSec(0),
+ fN(0),
+ fSectors(0),
+ fInput(0),
+ fOutput(0),
+ fSeedTree(0),
+ fTreeDebug(0),
+ fEvent(0),
+ fDebug(0),
+ fNewIO(kFALSE),
+ fNtracks(0),
+ fSeeds(0),
+ fIteration(0),
+ fParam(0),
+ fDebugStreamer(0)
{
//------------------------------------
// dummy copy constructor
//------------------------------------------------------------------
+ fOutput=t.fOutput;
}
AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/){
//------------------------------
arrtr->ExpandCreateFast(160);
TClonesArray * arre = new TClonesArray("AliTPCExactPoint",160);
//
- vseed->fPoints = arrtr;
- vseed->fEPoints = arre;
+ vseed->SetPoints(arrtr);
+ vseed->SetEPoints(arre);
// vseed->fClusterPoints = arrcl;
fSeedTree->Branch("seeds","AliTPCseed",&vseed,32000,99);
delete arrtr;
continue;
}
- if ( (pt->GetNumberOfClusters()>70)&& (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.55) {
+ if ( (pt->GetNumberOfClusters()>70)&& (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.55) {
AliESDtrack iotrack;
iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
iotrack.SetTPCPoints(pt->GetPoints());
//
// short tracks - maybe decays
- if ( (pt->GetNumberOfClusters()>30) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.70) {
+ if ( (pt->GetNumberOfClusters()>30) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.70) {
Int_t found,foundable,shared;
pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE);
- if ( (found>20) && (pt->fNShared/float(pt->GetNumberOfClusters())<0.2)){
+ if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2)){
AliESDtrack iotrack;
iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
//iotrack.SetTPCindex(i);
}
}
- if ( (pt->GetNumberOfClusters()>20) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->fNFoundable))>0.8) {
+ if ( (pt->GetNumberOfClusters()>20) && (Float_t(pt->GetNumberOfClusters())/Float_t(pt->GetNFoundable()))>0.8) {
Int_t found,foundable,shared;
pt->GetClusterStatistic(0,60,found, foundable,shared,kFALSE);
if (found<20) continue;
- if (pt->fNShared/float(pt->GetNumberOfClusters())>0.2) continue;
+ if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue;
//
AliESDtrack iotrack;
iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
if ( (pt->GetNumberOfClusters()>30) ) {
Int_t found,foundable,shared;
pt->GetClusterStatistic(128,158,found, foundable,shared,kFALSE);
- if ( (found>20) && (pt->fNShared/float(pt->GetNumberOfClusters())<0.2) &&float(found)/float(foundable)>0.8){
+ if ( (found>20) && (pt->GetNShared()/float(pt->GetNumberOfClusters())<0.2) &&float(found)/float(foundable)>0.8){
AliESDtrack iotrack;
iotrack.UpdateTrackParams(pt,AliESDtrack::kTPCin);
iotrack.SetTPCPoints(pt->GetPoints());
Int_t found,foundable,shared;
pt->GetClusterStatistic(138,158,found, foundable,shared,kFALSE);
if (found<15) continue;
- if (pt->fNShared/float(pt->GetNumberOfClusters())>0.2) continue;
+ if (foundable<=0) continue;
+ if (pt->GetNShared()/float(pt->GetNumberOfClusters())>0.2) continue;
if (float(found)/float(foundable)<0.8) continue;
//
AliESDtrack iotrack;
if (!pt) continue;
AliTPCtrack * track = new AliTPCtrack(*pt);
iotrack = track;
- pt->fLab2 =i;
+ pt->SetLab2(i);
// br->SetAddress(&iotrack);
fOutput->Fill();
delete track;
//arrcl->ExpandCreateFast(160);
TClonesArray * arre = new TClonesArray("AliTPCExactPoint",160);
//
- vseed->fPoints = arrtr;
- vseed->fEPoints = arre;
+ vseed->SetPoints(arrtr);
+ vseed->SetEPoints(arre);
// vseed->fClusterPoints = arrcl;
//TBranch * brseed = seedtree->Branch("seeds","AliTPCseed",&vseed,32000,99);
TBranch * brseed = fSeedTree->GetBranch("seeds");
for (Int_t i=0; i<nseed; i++) {
AliTPCseed *pt=(AliTPCseed*)fSeeds->UncheckedAt(i);
if (!pt) continue;
- pt->fPoints = arrtr;
+ pt->SetPoints(arrtr);
// pt->fClusterPoints = arrcl;
- pt->fEPoints = arre;
+ pt->SetEPoints(arre);
pt->RebuildSeed();
vseed = pt;
brseed->SetAddress(&vseed);
fSeedTree->Fill();
- pt->fPoints = 0;
- pt->fEPoints = 0;
+ pt->SetPoints(0);
+ pt->SetEPoints(0);
// pt->fClusterPoints = 0;
}
fSeedTree->Write();
Float_t snoise2;
Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ()));
Int_t ctype = cl->GetType();
- Float_t padlength= GetPadPitchLength(seed->fRow);
- Float_t angle2 = seed->GetSnp()*seed->GetSnp();
+ Float_t padlength= GetPadPitchLength(seed->GetRow());
+ Double_t angle2 = seed->GetSnp()*seed->GetSnp();
angle2 = angle2/(1-angle2);
//
//cluster "quality"
- Int_t rsigmay = int(100.*cl->GetSigmaY2()/(seed->fCurrentSigmaY2));
+ Int_t rsigmay = int(100.*cl->GetSigmaY2()/(seed->GetCurrentSigmaY2()));
Float_t res;
//
if (fSectors==fInnerSec){
Float_t snoise2;
Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ()));
Int_t ctype = cl->GetType();
- Float_t padlength= GetPadPitchLength(seed->fRow);
+ Float_t padlength= GetPadPitchLength(seed->GetRow());
//
- Float_t angle2 = seed->GetSnp()*seed->GetSnp();
+ Double_t angle2 = seed->GetSnp()*seed->GetSnp();
// if (angle2<0.6) angle2 = 0.6;
angle2 = seed->GetTgl()*seed->GetTgl()*(1+angle2/(1-angle2));
//
//cluster "quality"
- Int_t rsigmaz = int(100.*cl->GetSigmaZ2()/(seed->fCurrentSigmaZ2));
+ Int_t rsigmaz = int(100.*cl->GetSigmaZ2()/(seed->GetCurrentSigmaZ2()));
Float_t res;
//
if (fSectors==fInnerSec){
Float_t ymax = x*TMath::Tan(0.5*fSectors->GetAlpha());
if (y > ymax) {
- seed->fRelativeSector= (seed->fRelativeSector+1) % fN;
+ seed->SetRelativeSector((seed->GetRelativeSector()+1) % fN);
if (!seed->Rotate(fSectors->GetAlpha()))
return;
} else if (y <-ymax) {
- seed->fRelativeSector= (seed->fRelativeSector-1+fN) % fN;
+ seed->SetRelativeSector((seed->GetRelativeSector()-1+fN) % fN);
if (!seed->Rotate(-fSectors->GetAlpha()))
return;
}
//
Int_t sec,row;
fParam->AdjustSectorRow(clrow->GetID(),sec,row);
+ for (Int_t icl=0; icl<clrow->GetArray()->GetEntriesFast(); icl++){
+ Transform((AliCluster*)(clrow->GetArray()->At(icl)));
+ }
//
AliTPCRow * tpcrow=0;
Int_t left=0;
left = (sec-fkNIS*2)/fkNOS;
}
if (left ==0){
- tpcrow->fN1 = clrow->GetArray()->GetEntriesFast();
- tpcrow->fClusters1 = new AliTPCclusterMI[tpcrow->fN1];
- for (Int_t i=0;i<tpcrow->fN1;i++)
- tpcrow->fClusters1[i] = *(AliTPCclusterMI*)(clrow->GetArray()->At(i));
+ tpcrow->SetN1(clrow->GetArray()->GetEntriesFast());
+ tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]);
+ for (Int_t i=0;i<tpcrow->GetN1();i++)
+ tpcrow->SetCluster1(i, *(AliTPCclusterMI*)(clrow->GetArray()->At(i)));
}
if (left ==1){
- tpcrow->fN2 = clrow->GetArray()->GetEntriesFast();
- tpcrow->fClusters2 = new AliTPCclusterMI[tpcrow->fN2];
- for (Int_t i=0;i<tpcrow->fN2;i++)
- tpcrow->fClusters2[i] = *(AliTPCclusterMI*)(clrow->GetArray()->At(i));
+ tpcrow->SetN2(clrow->GetArray()->GetEntriesFast());
+ tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]);
+ for (Int_t i=0;i<tpcrow->GetN2();i++)
+ tpcrow->SetCluster2(i,*(AliTPCclusterMI*)(clrow->GetArray()->At(i)));
}
}
//
return ;
}
+void AliTPCtrackerMI::Transform(AliCluster * cluster){
+ //
+ //
+ //
+ //if (!fParam->IsGeoRead()) fParam->ReadGeoMatrices();
+ TGeoHMatrix *mat = fParam->GetClusterMatrix(cluster->GetDetector());
+ //TGeoHMatrix mat;
+ Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
+ Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
+ if (mat) mat->LocalToMaster(pos,posC);
+ else{
+ // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
+ }
+ cluster->SetX(posC[0]);
+ cluster->SetY(posC[1]);
+ cluster->SetZ(posC[2]);
+}
//_____________________________________________________________________________
Int_t AliTPCtrackerMI::LoadOuterSectors() {
AliTPCRow* tpcrow = &(fOuterSec[sec%fkNOS][row]);
Int_t sec2 = sec+2*fkNIS;
//left
- Int_t ncl = tpcrow->fN1;
+ Int_t ncl = tpcrow->GetN1();
while (ncl--) {
- AliTPCclusterMI *c= &(tpcrow->fClusters1[ncl]);
+ AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl));
index=(((sec2<<8)+row)<<16)+ncl;
tpcrow->InsertCluster(c,index);
}
//right
- ncl = tpcrow->fN2;
+ ncl = tpcrow->GetN2();
while (ncl--) {
- AliTPCclusterMI *c= &(tpcrow->fClusters2[ncl]);
+ AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl));
index=((((sec2+fkNOS)<<8)+row)<<16)+ncl;
tpcrow->InsertCluster(c,index);
}
// write indexes for fast acces
//
for (Int_t i=0;i<510;i++)
- tpcrow->fFastCluster[i]=-1;
+ tpcrow->SetFastCluster(i,-1);
for (Int_t i=0;i<tpcrow->GetN();i++){
Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.);
- tpcrow->fFastCluster[zi]=i; // write index
+ tpcrow->SetFastCluster(zi,i); // write index
}
Int_t last = 0;
for (Int_t i=0;i<510;i++){
- if (tpcrow->fFastCluster[i]<0)
- tpcrow->fFastCluster[i] = last;
+ if (tpcrow->GetFastCluster(i)<0)
+ tpcrow->SetFastCluster(i,last);
else
- last = tpcrow->fFastCluster[i];
+ last = tpcrow->GetFastCluster(i);
}
}
fN=fkNOS;
AliTPCRow* tpcrow = &(fInnerSec[sec%fkNIS][row]);
//
//left
- Int_t ncl = tpcrow->fN1;
+ Int_t ncl = tpcrow->GetN1();
while (ncl--) {
- AliTPCclusterMI *c= &(tpcrow->fClusters1[ncl]);
+ AliTPCclusterMI *c= (tpcrow->GetCluster1(ncl));
index=(((sec<<8)+row)<<16)+ncl;
tpcrow->InsertCluster(c,index);
}
//right
- ncl = tpcrow->fN2;
+ ncl = tpcrow->GetN2();
while (ncl--) {
- AliTPCclusterMI *c= &(tpcrow->fClusters2[ncl]);
+ AliTPCclusterMI *c= (tpcrow->GetCluster2(ncl));
index=((((sec+fkNIS)<<8)+row)<<16)+ncl;
tpcrow->InsertCluster(c,index);
}
// write indexes for fast acces
//
for (Int_t i=0;i<510;i++)
- tpcrow->fFastCluster[i]=-1;
+ tpcrow->SetFastCluster(i,-1);
for (Int_t i=0;i<tpcrow->GetN();i++){
Int_t zi = Int_t((*tpcrow)[i]->GetZ()+255.);
- tpcrow->fFastCluster[zi]=i; // write index
+ tpcrow->SetFastCluster(zi,i); // write index
}
Int_t last = 0;
for (Int_t i=0;i<510;i++){
- if (tpcrow->fFastCluster[i]<0)
- tpcrow->fFastCluster[i] = last;
+ if (tpcrow->GetFastCluster(i)<0)
+ tpcrow->SetFastCluster(i,last);
else
- last = tpcrow->fFastCluster[i];
+ last = tpcrow->GetFastCluster(i);
}
}
//--------------------------------------------------------------------
// Return pointer to a given cluster
//--------------------------------------------------------------------
+ if (index<0) return 0; // no cluster
Int_t sec=(index&0xff000000)>>24;
Int_t row=(index&0x00ff0000)>>16;
Int_t ncl=(index&0x00007fff)>>00;
const AliTPCRow * tpcrow=0;
AliTPCclusterMI * clrow =0;
+ if (sec<0 || sec>=fkNIS*4) {
+ AliWarning(Form("Wrong sector %d",sec));
+ return 0x0;
+ }
+
if (sec<fkNIS*2){
tpcrow = &(fInnerSec[sec%fkNIS][row]);
if (tpcrow==0) return 0;
if (sec<fkNIS) {
- if (tpcrow->fN1<=ncl) return 0;
- clrow = tpcrow->fClusters1;
+ if (tpcrow->GetN1()<=ncl) return 0;
+ clrow = tpcrow->GetClusters1();
}
else {
- if (tpcrow->fN2<=ncl) return 0;
- clrow = tpcrow->fClusters2;
+ if (tpcrow->GetN2()<=ncl) return 0;
+ clrow = tpcrow->GetClusters2();
}
}
else {
if (tpcrow==0) return 0;
if (sec-2*fkNIS<fkNOS) {
- if (tpcrow->fN1<=ncl) return 0;
- clrow = tpcrow->fClusters1;
+ if (tpcrow->GetN1()<=ncl) return 0;
+ clrow = tpcrow->GetClusters1();
}
else {
- if (tpcrow->fN2<=ncl) return 0;
- clrow = tpcrow->fClusters2;
+ if (tpcrow->GetN2()<=ncl) return 0;
+ clrow = tpcrow->GetClusters2();
}
}
//
if (tpcindex==-1) return 0; //track in dead zone
if (tpcindex>0){ //
- cl = t.fClusterPointer[nr];
+ cl = t.GetClusterPointer(nr);
if ( (cl==0) ) cl = GetClusterMI(tpcindex);
- t.fCurrentClusterIndex1 = tpcindex;
+ t.SetCurrentClusterIndex1(tpcindex);
}
if (cl){
Int_t relativesector = ((tpcindex&0xff000000)>>24)%18; // if previously accepted cluster in different sector
if (TMath::Abs(angle-t.GetAlpha())>0.001){
Double_t rotation = angle-t.GetAlpha();
- t.fRelativeSector= relativesector;
- t.Rotate(rotation);
+ t.SetRelativeSector(relativesector);
+ if (!t.Rotate(rotation)) return 0;
}
- t.PropagateTo(x);
+ if (!t.PropagateTo(x)) return 0;
//
- t.fCurrentCluster = cl;
- t.fRow = nr;
- Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.);
+ t.SetCurrentCluster(cl);
+ t.SetRow(nr);
+ Int_t accept = AcceptCluster(&t,t.GetCurrentCluster(),1.);
if ((tpcindex&0x8000)==0) accept =0;
if (accept<3) {
//if founded cluster is acceptible
if (cl->IsUsed(11)) { // id cluster is shared inrease uncertainty
- t.fErrorY2 += 0.03;
- t.fErrorZ2 += 0.03;
- t.fErrorY2 *= 3;
- t.fErrorZ2 *= 3;
+ t.SetErrorY2(t.GetErrorY2()+0.03);
+ t.SetErrorZ2(t.GetErrorZ2()+0.03);
+ t.SetErrorY2(t.GetErrorY2()*3);
+ t.SetErrorZ2(t.GetErrorZ2()*3);
}
- t.fNFoundable++;
+ t.SetNFoundable(t.GetNFoundable()+1);
UpdateTrack(&t,accept);
return 1;
}
}
}
- if (fIteration>1) return 0; // not look for new cluster during refitting
+ if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0; // cut on angle
+ if (fIteration>1){
+ // not look for new cluster during refitting
+ t.SetNFoundable(t.GetNFoundable()+1);
+ return 0;
+ }
//
UInt_t index=0;
- if (TMath::Abs(t.GetSnp())>0.95 || TMath::Abs(x*t.GetC()-t.GetEta())>0.95) return 0;
+ // if (TMath::Abs(t.GetSnp())>0.95 || TMath::Abs(x*t.GetC()-t.GetEta())>0.95) return 0;// patch 28 fev 06
Double_t y=t.GetYat(x);
if (TMath::Abs(y)>ymax){
if (y > ymax) {
- t.fRelativeSector= (t.fRelativeSector+1) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
if (!t.Rotate(fSectors->GetAlpha()))
return 0;
} else if (y <-ymax) {
- t.fRelativeSector= (t.fRelativeSector-1+fN) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
if (!t.Rotate(-fSectors->GetAlpha()))
return 0;
}
}
//
if (!t.PropagateTo(x)) {
- if (fIteration==0) t.fRemoval = 10;
+ if (fIteration==0) t.SetRemoval(10);
return 0;
}
y=t.GetY();
Double_t z=t.GetZ();
//
- const AliTPCRow &krow=GetRow(t.fRelativeSector,nr);
+
+ if (!IsActive(t.GetRelativeSector(),nr)) {
+ t.SetInDead(kTRUE);
+ t.SetClusterIndex2(nr,-1);
+ return 0;
+ }
+ //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));
+ Bool_t isActive = IsActive(t.GetRelativeSector(),nr);
+ Bool_t isActive2 = (nr>=fInnerSec->GetNRows()) ? fOuterSec[t.GetRelativeSector()][nr-fInnerSec->GetNRows()].GetN()>0:fInnerSec[t.GetRelativeSector()][nr].GetN()>0;
+
+ if (!isActive || !isActive2) return 0;
+
+ const AliTPCRow &krow=GetRow(t.GetRelativeSector(),nr);
if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0;
Double_t roady =1.;
Double_t roadz = 1.;
//
- if (TMath::Abs(TMath::Abs(y)-ymax)<krow.fDeadZone){
- t.fInDead = kTRUE;
+ if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
+ t.SetInDead(kTRUE);
t.SetClusterIndex2(nr,-1);
return 0;
}
else
{
- if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10)) t.fNFoundable++;
+ if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fParam->GetZLength() && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker()))
+ t.SetNFoundable(t.GetNFoundable()+1);
else
return 0;
}
if (krow) {
// cl = krow.FindNearest2(y+10.,z,roady,roadz,index);
cl = krow.FindNearest2(y,z,roady,roadz,index);
- if (cl) t.fCurrentClusterIndex1 = krow.GetIndex(index);
+ if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(index));
}
if (cl) {
- t.fCurrentCluster = cl;
- t.fRow = nr;
+ t.SetCurrentCluster(cl);
+ t.SetRow(nr);
if (fIteration==2&&cl->IsUsed(10)) return 0;
- Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.);
+ Int_t accept = AcceptCluster(&t,t.GetCurrentCluster(),1.);
if (fIteration==2&&cl->IsUsed(11)) {
- t.fErrorY2 += 0.03;
- t.fErrorZ2 += 0.03;
- t.fErrorY2 *= 3;
- t.fErrorZ2 *= 3;
+ t.SetErrorY2(t.GetErrorY2()+0.03);
+ t.SetErrorZ2(t.GetErrorZ2()+0.03);
+ t.SetErrorY2(t.GetErrorY2()*3);
+ t.SetErrorZ2(t.GetErrorZ2()*3);
}
/*
if (t.fCurrentCluster->IsUsed(10)){
if (accept<3) UpdateTrack(&t,accept);
} else {
- if ( fIteration==0 && t.fNFoundable*0.5 > t.GetNumberOfClusters()) t.fRemoval=10;
+ if ( fIteration==0 && t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) t.SetRemoval(10);
}
return 1;
Double_t x= GetXrow(nr), ymax=GetMaxY(nr);
Double_t y,z;
if (!t.GetProlongation(x,y,z)) {
- t.fRemoval = 10;
+ t.SetRemoval(10);
return 0;
}
//
if (TMath::Abs(y)>ymax){
if (y > ymax) {
- t.fRelativeSector= (t.fRelativeSector+1) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
if (!t.Rotate(fSectors->GetAlpha()))
return 0;
} else if (y <-ymax) {
- t.fRelativeSector= (t.fRelativeSector-1+fN) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
if (!t.Rotate(-fSectors->GetAlpha()))
return 0;
}
}
//
// update current shape info every 3 pad-row
- if ( (nr%6==0) || t.GetNumberOfClusters()<2 || (t.fCurrentSigmaY2<0.0001) ){
+ if ( (nr%6==0) || t.GetNumberOfClusters()<2 || (t.GetCurrentSigmaY2()<0.0001) ){
// t.fCurrentSigmaY = GetSigmaY(&t);
//t.fCurrentSigmaZ = GetSigmaZ(&t);
GetShape(&t,nr);
//Int_t nr2 = nr;
- const AliTPCRow &krow=GetRow(t.fRelativeSector,nr);
+ const AliTPCRow &krow=GetRow(t.GetRelativeSector(),nr);
if ( (t.GetSigmaY2()<0) || t.GetSigmaZ2()<0) return 0;
Double_t roady =1.;
Double_t roadz = 1.;
//
Int_t row = nr;
- if (TMath::Abs(TMath::Abs(y)-ymax)<krow.fDeadZone){
- t.fInDead = kTRUE;
+ if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
+ t.SetInDead(kTRUE);
t.SetClusterIndex2(row,-1);
return 0;
}
// cl = krow.FindNearest2(y+10,z,roady,roadz,index);
cl = krow.FindNearest2(y,z,roady,roadz,index);
- if (cl) t.fCurrentClusterIndex1 = krow.GetIndex(index);
+ if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(index));
}
if (cl) {
- t.fCurrentCluster = cl;
+ t.SetCurrentCluster(cl);
// Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.);
//if (accept<3){
t.SetClusterIndex2(row,index);
- t.fClusterPointer[row] = cl;
+ t.SetClusterPointer(row, cl);
//}
}
return 1;
+//_________________________________________________________________________
+Bool_t AliTPCtrackerMI::GetTrackPoint(Int_t index, AliTrackPoint &p ) const
+{
+ // Get track space point by index
+ // return false in case the cluster doesn't exist
+ AliTPCclusterMI *cl = GetClusterMI(index);
+ if (!cl) return kFALSE;
+ Int_t sector = (index&0xff000000)>>24;
+ // Int_t row = (index&0x00ff0000)>>16;
+ Float_t xyz[3];
+ // xyz[0] = fParam->GetPadRowRadii(sector,row);
+ xyz[0] = cl->GetX();
+ xyz[1] = cl->GetY();
+ xyz[2] = cl->GetZ();
+ Float_t sin,cos;
+ fParam->AdjustCosSin(sector,cos,sin);
+ Float_t x = cos*xyz[0]-sin*xyz[1];
+ Float_t y = cos*xyz[1]+sin*xyz[0];
+ Float_t cov[6];
+ Float_t sigmaY2 = 0.027*cl->GetSigmaY2();
+ if (sector < fParam->GetNInnerSector()) sigmaY2 *= 2.07;
+ Float_t sigmaZ2 = 0.066*cl->GetSigmaZ2();
+ if (sector < fParam->GetNInnerSector()) sigmaZ2 *= 1.77;
+ cov[0] = sin*sin*sigmaY2;
+ cov[1] = -sin*cos*sigmaY2;
+ cov[2] = 0.;
+ cov[3] = cos*cos*sigmaY2;
+ cov[4] = 0.;
+ cov[5] = sigmaZ2;
+ p.SetXYZ(x,y,xyz[2],cov);
+ AliAlignObj::ELayerID iLayer;
+ Int_t idet;
+ if (sector < fParam->GetNInnerSector()) {
+ iLayer = AliAlignObj::kTPC1;
+ idet = sector;
+ }
+ else {
+ iLayer = AliAlignObj::kTPC2;
+ idet = sector - fParam->GetNInnerSector();
+ }
+ UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,idet);
+ p.SetVolumeID(volid);
+ return kTRUE;
+}
+
+
+
Int_t AliTPCtrackerMI::UpdateClusters(AliTPCseed& t, Int_t nr) {
//-----------------------------------------------------------------
// This function tries to find a track prolongation to next pad row
//-----------------------------------------------------------------
- t.fCurrentCluster = 0;
- t.fCurrentClusterIndex1 = 0;
+ t.SetCurrentCluster(0);
+ t.SetCurrentClusterIndex1(0);
Double_t xt=t.GetX();
Int_t row = GetRowNumber(xt)-1;
Double_t ymax= GetMaxY(nr);
if (row < nr) return 1; // don't prolongate if not information until now -
- if (TMath::Abs(t.GetSnp())>0.9 && t.GetNumberOfClusters()>40. && fIteration!=2) {
- t.fRemoval =10;
- return 0; // not prolongate strongly inclined tracks
- }
- if (TMath::Abs(t.GetSnp())>0.95) {
- t.fRemoval =10;
- return 0; // not prolongate strongly inclined tracks
- }
+// if (TMath::Abs(t.GetSnp())>0.9 && t.GetNumberOfClusters()>40. && fIteration!=2) {
+// t.fRemoval =10;
+// return 0; // not prolongate strongly inclined tracks
+// }
+// if (TMath::Abs(t.GetSnp())>0.95) {
+// t.fRemoval =10;
+// return 0; // not prolongate strongly inclined tracks
+// }// patch 28 fev 06
Double_t x= GetXrow(nr);
Double_t y,z;
if (TMath::Abs(y)>ymax){
if (y > ymax) {
- t.fRelativeSector= (t.fRelativeSector+1) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
if (!t.Rotate(fSectors->GetAlpha()))
return 0;
} else if (y <-ymax) {
- t.fRelativeSector= (t.fRelativeSector-1+fN) % fN;
+ t.SetRelativeSector((t.GetRelativeSector()-1+fN) % fN);
if (!t.Rotate(-fSectors->GetAlpha()))
return 0;
}
//y = t.GetY();
}
//
+ if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0;
+
+ if (!IsActive(t.GetRelativeSector(),nr)) {
+ t.SetInDead(kTRUE);
+ t.SetClusterIndex2(nr,-1);
+ return 0;
+ }
+ //AliInfo(Form("A - Sector%d phi %f - alpha %f", t.fRelativeSector,y/x, t.GetAlpha()));
- AliTPCRow &krow=GetRow(t.fRelativeSector,nr);
+ AliTPCRow &krow=GetRow(t.GetRelativeSector(),nr);
- if (TMath::Abs(TMath::Abs(y)-ymax)<krow.fDeadZone){
- t.fInDead = kTRUE;
+ if (TMath::Abs(TMath::Abs(y)-ymax)<krow.GetDeadZone()){
+ t.SetInDead(kTRUE);
t.SetClusterIndex2(nr,-1);
return 0;
}
else
{
- if (TMath::Abs(t.GetZ())<(AliTPCReconstructor::GetCtgRange()*t.GetX()+10)) t.fNFoundable++;
+ if (TMath::Abs(t.GetZ())<(AliTPCReconstructor::GetCtgRange()*t.GetX()+10) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker())) t.SetNFoundable(t.GetNFoundable()+1);
else
return 0;
}
}
AliTPCclusterMI *cl=0;
- UInt_t index=0;
+ Int_t index=0;
//
Double_t roady = 1.;
Double_t roadz = 1.;
if (!cl){
index = t.GetClusterIndex2(nr);
if ( (index>0) && (index&0x8000)==0){
- cl = t.fClusterPointer[nr];
+ cl = t.GetClusterPointer(nr);
if ( (cl==0) && (index>0)) cl = GetClusterMI(index);
- t.fCurrentClusterIndex1 = index;
+ t.SetCurrentClusterIndex1(index);
if (cl) {
- t.fCurrentCluster = cl;
+ t.SetCurrentCluster(cl);
return 1;
}
}
}
+ // if (index<0) return 0;
+ UInt_t uindex = TMath::Abs(index);
+
if (krow) {
- //cl = krow.FindNearest2(y+10,z,roady,roadz,index);
- cl = krow.FindNearest2(y,z,roady,roadz,index);
+ //cl = krow.FindNearest2(y+10,z,roady,roadz,uindex);
+ cl = krow.FindNearest2(y,z,roady,roadz,uindex);
}
- if (cl) t.fCurrentClusterIndex1 = krow.GetIndex(index);
- t.fCurrentCluster = cl;
+ if (cl) t.SetCurrentClusterIndex1(krow.GetIndex(uindex));
+ t.SetCurrentCluster(cl);
return 1;
}
//update error according neighborhoud
- if (t.fCurrentCluster) {
- t.fRow = nr;
- Int_t accept = AcceptCluster(&t,t.fCurrentCluster,1.);
+ if (t.GetCurrentCluster()) {
+ t.SetRow(nr);
+ Int_t accept = AcceptCluster(&t,t.GetCurrentCluster(),1.);
- if (t.fCurrentCluster->IsUsed(10)){
+ if (t.GetCurrentCluster()->IsUsed(10)){
//
//
// t.fErrorZ2*=2;
// t.fErrorY2*=2;
- t.fNShared++;
- if (t.fNShared>0.7*t.GetNumberOfClusters()) {
- t.fRemoval =10;
+ t.SetNShared(t.GetNShared()+1);
+ if (t.GetNShared()>0.7*t.GetNumberOfClusters()) {
+ t.SetRemoval(10);
return 0;
}
}
} else {
if (fIteration==0){
- if ( ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)&& t.GetNumberOfClusters()>18) t.fRemoval=10;
- if ( t.GetChi2()/t.GetNumberOfClusters()>6 &&t.GetNumberOfClusters()>18) t.fRemoval=10;
+ if ( ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)&& t.GetNumberOfClusters()>18) t.SetRemoval(10);
+ if ( t.GetChi2()/t.GetNumberOfClusters()>6 &&t.GetNumberOfClusters()>18) t.SetRemoval(10);
- if (( (t.fNFoundable*0.5 > t.GetNumberOfClusters()) || t.fNoCluster>15)) t.fRemoval=10;
+ if (( (t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) || t.GetNoCluster()>15)) t.SetRemoval(10);
}
}
return 1;
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
//
- t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
+ t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
Int_t first = GetRowNumber(xt)-1;
for (Int_t nr= first; nr>=rf; nr-=step) {
if (index==0) break;
if (index<0) continue;
//
- AliESDkink * kink = fEvent->GetKink(index-1);
+ AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
if (!kink){
printf("PROBLEM\n");
}
Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
- t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
+ t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
for (Int_t nr=GetRowNumber(xt)-1; nr>=rf; nr-=step) {
Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
- t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
+ t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
- Int_t first = t.fFirstPoint;
+ Int_t first = t.GetFirstPoint();
if (first<GetRowNumber(xt)+1) first = GetRowNumber(xt)+1;
//
if (first<0) first=0;
for (Int_t nr=first; nr<=rf; nr++) {
- if ( (TMath::Abs(t.GetSnp())>0.95)) break;
+ // if ( (TMath::Abs(t.GetSnp())>0.95)) break;//patch 28 fev 06
if (t.GetKinkIndexes()[0]<0){
for (Int_t i=0;i<3;i++){
Int_t index = t.GetKinkIndexes()[i];
if (index==0) break;
if (index>0) continue;
index = TMath::Abs(index);
- AliESDkink * kink = fEvent->GetKink(index-1);
+ AliKink * kink = (AliKink*)fEvent->GetKink(index-1);
if (!kink){
printf("PROBLEM\n");
}
fSectors = fInnerSec;
else
fSectors = fOuterSec;
+
FollowToNext(t,nr);
}
return 1;
if (distance>4.) return 0; // if there are far away - not overlap - to reduce combinatorics
// Int_t offset =0;
- Int_t firstpoint = TMath::Min(s1->fFirstPoint,s2->fFirstPoint);
- Int_t lastpoint = TMath::Max(s1->fLastPoint,s2->fLastPoint);
+ Int_t firstpoint = TMath::Min(s1->GetFirstPoint(),s2->GetFirstPoint());
+ Int_t lastpoint = TMath::Max(s1->GetLastPoint(),s2->GetLastPoint());
if (lastpoint>160)
lastpoint =160;
if (firstpoint<0)
//
Int_t sumshared=0;
//
- Int_t firstpoint = TMath::Max(s1->fFirstPoint,s2->fFirstPoint);
- Int_t lastpoint = TMath::Min(s1->fLastPoint,s2->fLastPoint);
+ Int_t firstpoint = TMath::Max(s1->GetFirstPoint(),s2->GetFirstPoint());
+ Int_t lastpoint = TMath::Min(s1->GetLastPoint(),s2->GetLastPoint());
//
if (firstpoint>=lastpoint-5) return;;
AliTPCTrackerPoint *p1 = s1->GetTrackPoint(i);
AliTPCTrackerPoint *p2 = s2->GetTrackPoint(i);;
if (s1->IsActive()&&s2->IsActive()){
- p1->fIsShared = kTRUE;
- p2->fIsShared = kTRUE;
+ p1->SetShared(kTRUE);
+ p2->SetShared(kTRUE);
}
}
}
//
if (sumshared>10){
for (Int_t i=0;i<4;i++){
- if (s1->fOverlapLabels[3*i]==0){
- s1->fOverlapLabels[3*i] = s2->GetLabel();
- s1->fOverlapLabels[3*i+1] = sumshared;
- s1->fOverlapLabels[3*i+2] = s2->GetUniqueID();
+ if (s1->GetOverlapLabel(3*i)==0){
+ s1->SetOverlapLabel(3*i, s2->GetLabel());
+ s1->SetOverlapLabel(3*i+1,sumshared);
+ s1->SetOverlapLabel(3*i+2,s2->GetUniqueID());
break;
}
}
for (Int_t i=0;i<4;i++){
- if (s2->fOverlapLabels[3*i]==0){
- s2->fOverlapLabels[3*i] = s1->GetLabel();
- s2->fOverlapLabels[3*i+1] = sumshared;
- s2->fOverlapLabels[3*i+2] = s1->GetUniqueID();
+ if (s2->GetOverlapLabel(3*i)==0){
+ s2->SetOverlapLabel(3*i, s1->GetLabel());
+ s2->SetOverlapLabel(3*i+1,sumshared);
+ s2->SetOverlapLabel(3*i+2,s1->GetUniqueID());
break;
}
}
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
//if (pt) RotateToLocal(pt);
- pt->fSort = 0;
+ pt->SetSort(0);
}
arr->UnSort();
arr->Sort(); // sorting according z
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
for (Int_t j=0;j<=12;j++){
- pt->fOverlapLabels[j] =0;
+ pt->SetOverlapLabel(j,0);
}
}
for (Int_t i=0; i<nseed; i++) {
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
- if (pt->fRemoval>10) continue;
+ if (pt->GetRemoval()>10) continue;
for (Int_t j=i+1; j<nseed; j++){
AliTPCseed *pt2=(AliTPCseed*)arr->UncheckedAt(j);
// if (pt2){
- if (pt2->fRemoval<=10) {
- if ( TMath::Abs(pt->fRelativeSector-pt2->fRelativeSector)>0) break;
+ if (pt2->GetRemoval()<=10) {
+ if ( TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>0) break;
SignShared(pt,pt2);
}
}
for (Int_t i=0; i<arr->GetEntriesFast(); i++) {
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
- pt->fSort = 0;
+ pt->SetSort(0);
}
arr->UnSort();
arr->Sort(); // sorting according z
if (!pt) continue;
pt->SetUniqueID(i);
for (Int_t j=0;j<=12;j++){
- pt->fOverlapLabels[j] =0;
+ pt->SetOverlapLabel(j,0);
}
}
//
for (Int_t i=0; i<nseed; i++) {
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
- if (pt->fRemoval>10) continue;
+ if (pt->GetRemoval()>10) continue;
Float_t deltac = pt->GetC()*0.1;
for (Int_t j=i+1; j<nseed; j++){
AliTPCseed *pt2=(AliTPCseed*)arr->UncheckedAt(j);
// if (pt2){
- if (pt2->fRemoval<=10) {
- if ( TMath::Abs(pt->fRelativeSector-pt2->fRelativeSector)>0) break;
+ if (pt2->GetRemoval()<=10) {
+ if ( TMath::Abs(pt->GetRelativeSector()-pt2->GetRelativeSector())>0) break;
if (TMath::Abs(pt->GetC() -pt2->GetC())>deltac) continue;
if (TMath::Abs(pt->GetTgl()-pt2->GetTgl())>0.05) continue;
//
for (Int_t i=0; i<nseed; i++) {
AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
if (!pt) continue;
- if (pt->fRemoval>10) continue;
+ if (pt->GetRemoval()>10) continue;
//
Int_t sumshared =0;
for (Int_t j=0;j<4;j++){
- sumshared = pt->fOverlapLabels[j*3+1];
+ sumshared = pt->GetOverlapLabel(j*3+1);
}
Float_t factor = factor1;
- if (pt->fRemoval>0) factor = factor2;
+ if (pt->GetRemoval()>0) factor = factor2;
if (sumshared/pt->GetNumberOfClusters()>factor){
for (Int_t j=0;j<4;j++){
- if (pt->fOverlapLabels[3*j]==0) continue;
- if (pt->fOverlapLabels[3*j+1]<5) continue;
- if (pt->fRemoval==removalindex) continue;
- AliTPCseed * pt2 = (AliTPCseed*)arr->UncheckedAt(pt->fOverlapLabels[3*j+2]);
+ if (pt->GetOverlapLabel(3*j)==0) continue;
+ if (pt->GetOverlapLabel(3*j+1)<5) continue;
+ if (pt->GetRemoval()==removalindex) continue;
+ AliTPCseed * pt2 = (AliTPCseed*)arr->UncheckedAt(pt->GetOverlapLabel(3*j+2));
if (!pt2) continue;
if (pt2->GetSigma2C()<pt->GetSigma2C()){
// pt->fRemoval = removalindex;
if (!pt) {
continue;
}
- pt->fSort = mode;
+ pt->SetSort(mode);
}
arr->UnSort();
arr->Sort();
delete arr->RemoveAt(i);
}
else{
- pt->fSort =1;
- pt->fBSigned = kFALSE;
+ pt->SetSort(1);
+ pt->SetBSigned(kFALSE);
}
}
arr->Compress();
pt->GetClusterStatistic(0,160,found, foundable,shared,kTRUE);
//
Double_t factor = factor2;
- if (pt->fBConstrain) factor = factor1;
+ if (pt->GetBConstrain()) factor = factor1;
if ((Float_t(shared)/Float_t(found))>factor){
pt->Desactivate(removalindex);
for (Int_t i=0; i<160; i++) {
Int_t index=pt->GetClusterIndex2(i);
if (index<0 || index&0x8000 ) continue;
- AliTPCclusterMI *c= pt->fClusterPointer[i];
+ AliTPCclusterMI *c= pt->GetClusterPointer(i);
if (!c) continue;
// if (!c->IsUsed(10)) c->Use(10);
//if (pt->IsActive())
//
Int_t first = Int_t(pt->GetPoints()[0]);
Int_t last = Int_t(pt->GetPoints()[2]);
- Double_t factor = (pt->fBConstrain) ? factor1: factor2;
+ Double_t factor = (pt->GetBConstrain()) ? factor1: factor2;
//
Int_t found,foundable,shared;
pt->GetClusterStatistic(first,last, found, foundable,shared,kFALSE);
Float_t sharedfactor = Float_t(shared+1)/Float_t(found+1);
- //
- if (Float_t(shared+1)/Float_t(found+1)>factor){
- if (pt->GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks
- delete arr->RemoveAt(trackindex);
- continue;
+ Bool_t itsgold =kFALSE;
+ if (pt->GetESD()){
+ Int_t dummy[12];
+ if (pt->GetESD()->GetITSclusters(dummy)>4) itsgold= kTRUE;
}
-
- if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){ //remove short tracks
- if (pt->GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks
- delete arr->RemoveAt(trackindex);
- continue;
+ if (!itsgold){
+ //
+ if (Float_t(shared+1)/Float_t(found+1)>factor){
+ if (pt->GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks
+ delete arr->RemoveAt(trackindex);
+ continue;
+ }
+ if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){ //remove short tracks
+ if (pt->GetKinkIndexes()[0]!=0) continue; //don't remove tracks - part of the kinks
+ delete arr->RemoveAt(trackindex);
+ continue;
+ }
}
good++;
if (sharedfactor>0.4) continue;
+ if (pt->GetKinkIndexes()[0]>0) continue;
for (Int_t i=first; i<last; i++) {
Int_t index=pt->GetClusterIndex2(i);
// if (index<0 || index&0x8000 ) continue;
if (index<0 || index&0x8000 ) continue;
- AliTPCclusterMI *c= pt->fClusterPointer[i];
+ AliTPCclusterMI *c= pt->GetClusterPointer(i);
if (!c) continue;
c->Use(10);
}
for (Int_t sec=0;sec<fkNIS;sec++){
for (Int_t row=0;row<fInnerSec->GetNRows();row++){
- AliTPCclusterMI *cl = fInnerSec[sec][row].fClusters1;
- for (Int_t icl =0;icl< fInnerSec[sec][row].fN1;icl++)
+ AliTPCclusterMI *cl = fInnerSec[sec][row].GetClusters1();
+ for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++)
// if (cl[icl].IsUsed(10))
cl[icl].Use(-1);
- cl = fInnerSec[sec][row].fClusters2;
- for (Int_t icl =0;icl< fInnerSec[sec][row].fN2;icl++)
+ cl = fInnerSec[sec][row].GetClusters2();
+ for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++)
//if (cl[icl].IsUsed(10))
cl[icl].Use(-1);
}
for (Int_t sec=0;sec<fkNOS;sec++){
for (Int_t row=0;row<fOuterSec->GetNRows();row++){
- AliTPCclusterMI *cl = fOuterSec[sec][row].fClusters1;
- for (Int_t icl =0;icl< fOuterSec[sec][row].fN1;icl++)
+ AliTPCclusterMI *cl = fOuterSec[sec][row].GetClusters1();
+ for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++)
//if (cl[icl].IsUsed(10))
cl[icl].Use(-1);
- cl = fOuterSec[sec][row].fClusters2;
- for (Int_t icl =0;icl< fOuterSec[sec][row].fN2;icl++)
+ cl = fOuterSec[sec][row].GetClusters2();
+ for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++)
//if (cl[icl].IsUsed(10))
cl[icl].Use(-1);
}
continue;
}
if (!(pt->IsActive())) continue;
- Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->fNFoundable);
+ Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable());
if ( (dens>0.7) && (pt->GetNumberOfClusters()>70)){
sumdens += dens;
sumdens2+= dens*dens;
if (!pt) {
continue;
}
- if (pt->fBSigned) continue;
- if (pt->fBConstrain) continue;
+ if (pt->GetBSigned()) continue;
+ if (pt->GetBConstrain()) continue;
//if (!(pt->IsActive())) continue;
/*
Int_t found,foundable,shared;
}
*/
Bool_t isok =kFALSE;
- if ( (pt->fNShared/pt->GetNumberOfClusters()<0.5) &&pt->GetNumberOfClusters()>60)
+ if ( (pt->GetNShared()/pt->GetNumberOfClusters()<0.5) &&pt->GetNumberOfClusters()>60)
isok = kTRUE;
- if ((TMath::Abs(1/pt->GetC())<100.) && (pt->fNShared/pt->GetNumberOfClusters()<0.7))
+ if ((TMath::Abs(1/pt->GetC())<100.) && (pt->GetNShared()/pt->GetNumberOfClusters()<0.7))
isok =kTRUE;
if (TMath::Abs(pt->GetZ()/pt->GetX())>1.1)
isok =kTRUE;
for (Int_t i=0; i<160; i++) {
Int_t index=pt->GetClusterIndex2(i);
if (index<0) continue;
- AliTPCclusterMI *c= pt->fClusterPointer[i];
+ AliTPCclusterMI *c= pt->GetClusterPointer(i);
if (!c) continue;
//if (!(c->IsUsed(10))) c->Use();
c->Use(10);
continue;
}
//if (!(pt->IsActive())) continue;
- if (pt->fBSigned) continue;
+ if (pt->GetBSigned()) continue;
Double_t chi = pt->GetChi2()/pt->GetNumberOfClusters();
if (chi>maxchi) continue;
Float_t bfactor=1;
- Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->fNFoundable);
+ Float_t dens = pt->GetNumberOfClusters()/Float_t(pt->GetNFoundable());
//sign only tracks with enoug big density at the beginning
Double_t minn = TMath::Max(Int_t(meann-fnumber*smeann*bfactor),50);
// if (pt->fBConstrain) mindens = TMath::Max(mdensity-sdensity*fdensity*bfactor,0.65);
- if ( (pt->fRemoval==10) && (pt->GetSnp()>0.8)&&(dens>mindens))
+ if ( (pt->GetRemoval()==10) && (pt->GetSnp()>0.8)&&(dens>mindens))
minn=0;
if ((dens>mindens && pt->GetNumberOfClusters()>minn) && chi<maxchi ){
//Int_t noc=pt->GetNumberOfClusters();
- pt->fBSigned = kTRUE;
+ pt->SetBSigned(kTRUE);
for (Int_t i=0; i<160; i++) {
Int_t index=pt->GetClusterIndex2(i);
if (index<0) continue;
- AliTPCclusterMI *c= pt->fClusterPointer[i];
+ AliTPCclusterMI *c= pt->GetClusterPointer(i);
if (!c) continue;
// if (!(c->IsUsed(10))) c->Use();
c->Use(10);
Int_t sumgood1 = 0;
Int_t sumgood2 = 0;
Int_t foundable = 0;
- Int_t maxindex = seed->fLastPoint; //last foundable row
- if (seed->fNFoundable*th0 > seed->GetNumberOfClusters()) {
+ Int_t maxindex = seed->GetLastPoint(); //last foundable row
+ if (seed->GetNFoundable()*th0 > seed->GetNumberOfClusters()) {
seed->Desactivate(10) ;
return;
}
fIteration=2;
//PrepareForProlongation(fSeeds,1);
PropagateForward2(fSeeds);
+
Int_t ntracks=0;
Int_t nseed = fSeeds->GetEntriesFast();
for (Int_t i=0;i<nseed;i++){
AliESDtrack *esd=event->GetTrack(i);
seed->CookdEdx(0.02,0.6);
CookLabel(seed,0.1); //For comparison only
+ //
+ if (AliTPCReconstructor::StreamLevel()>0 && seed!=0&&esd!=0) {
+ TTreeSRedirector &cstream = *fDebugStreamer;
+ cstream<<"Crefit"<<
+ "Esd.="<<esd<<
+ "Track.="<<seed<<
+ "\n";
+ }
+
if (seed->GetNumberOfClusters()>15){
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;
+ Float_t dedx = seed->GetdEdx();
+ esd->SetTPCsignal(dedx, sdedx, ndedx);
+ //
+ // add seed to the esd track in Calib level
+ //
+ if (AliTPCReconstructor::StreamLevel()>0){
+ AliTPCseed * seedCopy = new AliTPCseed(*seed, kTRUE);
+ esd->AddCalibObject(seedCopy);
+ }
ntracks++;
}
else{
fEvent = event;
fIteration = 1;
- ReadSeeds(event,0);
- PropagateBack(fSeeds);
+ ReadSeeds(event,1);
+ PropagateBack(fSeeds);
+ RemoveUsed2(fSeeds,0.4,0.4,20);
+ //
Int_t nseed = fSeeds->GetEntriesFast();
Int_t ntracks=0;
for (Int_t i=0;i<nseed;i++){
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;
+ Float_t dedx = seed->GetdEdx();
+ esd->SetTPCsignal(dedx, sdedx, ndedx);
ntracks++;
+ Int_t eventnumber = event->GetEventNumber();// patch 28 fev 06
+ (*fDebugStreamer)<<"Cback"<<
+ "Tr0.="<<seed<<
+ "EventNr="<<eventnumber<<
+ "\n"; // patch 28 fev 06
}
}
//FindKinks(fSeeds,event);
Info("PropagateBack","Number of back propagated tracks %d",ntracks);
fEvent =0;
//WriteTracks();
+
return 0;
}
{
//
//delete Seeds
+
Int_t nseed = fSeeds->GetEntriesFast();
for (Int_t i=0;i<nseed;i++){
AliTPCseed * seed = (AliTPCseed*)fSeeds->At(i);
if (seed) delete fSeeds->RemoveAt(i);
}
delete fSeeds;
+
fSeeds =0;
}
ULong_t status=esd->GetStatus();
if (!(status&AliESDtrack::kTPCin)) continue;
AliTPCtrack t(*esd);
+ t.SetNumberOfClusters(0);
// AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha());
AliTPCseed *seed = new AliTPCseed(t/*,t.GetAlpha()*/);
for (Int_t ikink=0;ikink<3;ikink++) {
}
}
- if ((status==AliESDtrack::kTPCin)&&(direction==1)) seed->ResetCovariance();
- if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance();
+ if (((status&AliESDtrack::kITSout)==0)&&(direction==1)) seed->ResetCovariance(10.);
+ if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) {
fSeeds->AddAt(0,i);
delete seed;
continue;
}
if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) > 0 ) {
- Double_t par0[5],par1[5],x;
- esd->GetInnerExternalParameters(x,par0);
+ Double_t par0[5],par1[5],alpha,x;
+ esd->GetInnerExternalParameters(alpha,x,par0);
esd->GetExternalParameters(x,par1);
Double_t delta1 = TMath::Abs(par0[4]-par1[4])/(0.000000001+TMath::Abs(par0[4]+par1[4]));
Double_t delta2 = TMath::Abs(par0[3]-par1[3]);
if (esd->GetTRDncls()>0) trdchi2 = esd->GetTRDchi2()/esd->GetTRDncls();
//reset covariance if suspicious
if ( (delta1>0.1) || (delta2>0.006) ||trdchi2>7.)
- seed->ResetCovariance();
+ seed->ResetCovariance(10.);
}
//
delete seed;
continue;
}
- seed->fEsd = esd;
+ seed->SetESD(esd);
// sign clusters
- for (Int_t irow=0;irow<160;irow++){
- Int_t index = seed->GetClusterIndex2(irow);
- if (index>0){
- //
- AliTPCclusterMI * cl = GetClusterMI(index);
- seed->fClusterPointer[irow] = cl;
- if (cl){
- if ((index & 0x8000)==0){
- cl->Use(10); // accepted cluster
+ if (esd->GetKinkIndex(0)<=0){
+ for (Int_t irow=0;irow<160;irow++){
+ Int_t index = seed->GetClusterIndex2(irow);
+ if (index>0){
+ //
+ AliTPCclusterMI * cl = GetClusterMI(index);
+ seed->SetClusterPointer(irow,cl);
+ if (cl){
+ if ((index & 0x8000)==0){
+ cl->Use(10); // accepted cluster
+ }else{
+ cl->Use(6); // close cluster not accepted
+ }
}else{
- cl->Use(6); // close cluster not accepted
- }
- }else{
- Info("ReadSeeds","Not found cluster");
+ Info("ReadSeeds","Not found cluster");
+ }
}
}
}
Int_t ns =sec;
const AliTPCRow& kr1=GetRow(ns,i1);
- Double_t ymax = GetMaxY(i1)-kr1.fDeadZone-1.5;
- Double_t ymaxm = GetMaxY(imiddle)-kr1.fDeadZone-1.5;
+ Double_t ymax = GetMaxY(i1)-kr1.GetDeadZone()-1.5;
+ Double_t ymaxm = GetMaxY(imiddle)-kr1.GetDeadZone()-1.5;
//
// change cut on curvature if it can't reach this layer
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
UInt_t index=kr1.GetIndex(is);
- AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, ns*alpha+shift);
+ AliTPCseed *track=new(seed) AliTPCseed(x1, ns*alpha+shift, x, c, index);
- track->fIsSeeding = kTRUE;
- track->fSeed1 = i1;
- track->fSeed2 = i2;
- track->fSeedType=3;
+ track->SetIsSeeding(kTRUE);
+ track->SetSeed1(i1);
+ track->SetSeed2(i2);
+ track->SetSeedType(3);
//if (dsec==0) {
//Int_t rc = 1;
- track->fBConstrain =1;
+ track->SetBConstrain(1);
// track->fLastPoint = i1+fInnerSec->GetNRows(); // first cluster in track position
- track->fLastPoint = i1; // first cluster in track position
- track->fFirstPoint = track->fLastPoint;
+ track->SetLastPoint(i1); // first cluster in track position
+ track->SetFirstPoint(track->GetLastPoint());
if (track->GetNumberOfClusters()<(i1-i2)*0.5 ||
- track->GetNumberOfClusters() < track->fNFoundable*0.6 ||
- track->fNShared>0.4*track->GetNumberOfClusters() ) {
+ track->GetNumberOfClusters() < track->GetNFoundable()*0.6 ||
+ track->GetNShared()>0.4*track->GetNumberOfClusters() ) {
seed->Reset();
seed->~AliTPCseed();
continue;
}
nout1++;
// Z VERTEX CONDITION
- Double_t zv;
- zv = track->GetZ()+track->GetTgl()/track->GetC()*
- ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta()));
+ Double_t zv, bz=GetBz();
+ if ( !track->GetZAt(0.,bz,zv) ) continue;
if (TMath::Abs(zv-z3)>cuts[2]) {
FollowProlongation(*track, TMath::Max(i2-20,0));
- zv = track->GetZ()+track->GetTgl()/track->GetC()*
- ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta()));
+ if ( !track->GetZAt(0.,bz,zv) ) continue;
if (TMath::Abs(zv-z3)>cuts[2]){
FollowProlongation(*track, TMath::Max(i2-40,0));
- zv = track->GetZ()+track->GetTgl()/track->GetC()*
- ( asin(-track->GetEta()) - asin(track->GetX()*track->GetC()-track->GetEta()));
- if (TMath::Abs(zv-z3)>cuts[2] &&(track->GetNumberOfClusters() > track->fNFoundable*0.7)){
+ if ( !track->GetZAt(0.,bz,zv) ) continue;
+ if (TMath::Abs(zv-z3)>cuts[2] &&(track->GetNumberOfClusters() > track->GetNFoundable()*0.7)){
// make seed without constrain
AliTPCseed * track2 = MakeSeed(track,0.2,0.5,1.);
FollowProlongation(*track2, i2,1);
- track2->fBConstrain = kFALSE;
- track2->fSeedType = 1;
+ track2->SetBConstrain(kFALSE);
+ track2->SetSeedType(1);
arr->AddLast(track2);
seed->Reset();
seed->~AliTPCseed();
}
}
- track->fSeedType =0;
+ track->SetSeedType(0);
arr->AddLast(track);
seed = new AliTPCseed;
nout2++;
// don't consider other combinations
- if (track->GetNumberOfClusters() > track->fNFoundable*0.8)
+ if (track->GetNumberOfClusters() > track->GetNFoundable()*0.8)
break;
}
}
// first 3 padrows
Double_t x1 = GetXrow(i1-1);
const AliTPCRow& kr1=GetRow(sec,i1-1);
- Double_t y1max = GetMaxY(i1-1)-kr1.fDeadZone-1.5;
+ Double_t y1max = GetMaxY(i1-1)-kr1.GetDeadZone()-1.5;
//
Double_t x1p = GetXrow(i1);
const AliTPCRow& kr1p=GetRow(sec,i1);
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
UInt_t index=kr1.GetIndex(is);
- AliTPCseed *track=new(seed) AliTPCseed(index, x, c, x1, sec*alpha+shift);
+ AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index);
- track->fIsSeeding = kTRUE;
+ track->SetIsSeeding(kTRUE);
nin++;
FollowProlongation(*track, i1-7,1);
- if (track->GetNumberOfClusters() < track->fNFoundable*0.75 ||
- track->fNShared>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){
+ if (track->GetNumberOfClusters() < track->GetNFoundable()*0.75 ||
+ track->GetNShared()>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){
seed->Reset();
seed->~AliTPCseed();
continue;
nout2++;
//Int_t rc = 1;
FollowProlongation(*track, i2,1);
- track->fBConstrain =0;
- track->fLastPoint = i1+fInnerSec->GetNRows(); // first cluster in track position
- track->fFirstPoint = track->fLastPoint;
+ track->SetBConstrain(0);
+ track->SetLastPoint(i1+fInnerSec->GetNRows()); // first cluster in track position
+ track->SetFirstPoint(track->GetLastPoint());
if (track->GetNumberOfClusters()<(i1-i2)*0.5 ||
- track->GetNumberOfClusters()<track->fNFoundable*0.7 ||
- track->fNShared>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) {
+ track->GetNumberOfClusters()<track->GetNFoundable()*0.7 ||
+ track->GetNShared()>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) {
seed->Reset();
seed->~AliTPCseed();
continue;
FollowProlongation(*track, TMath::Max(i2-10,0),1);
AliTPCseed * track2 = MakeSeed(track,0.2,0.5,0.9);
FollowProlongation(*track2, i2,1);
- track2->fBConstrain = kFALSE;
- track2->fSeedType = 4;
+ track2->SetBConstrain(kFALSE);
+ track2->SetSeedType(4);
arr->AddLast(track2);
seed->Reset();
seed->~AliTPCseed();
Float_t erry = 0;
Float_t errz = 0;
- Double_t ymax = fSectors->GetMaxY(row0)-kr0.fDeadZone-1.5;
+ Double_t ymax = fSectors->GetMaxY(row0)-kr0.GetDeadZone()-1.5;
if (deltay>0 && TMath::Abs(ymax-TMath::Abs(y0))> deltay ) continue; // seed only at the edge
erry = (0.5)*cl->GetSigmaY2()/TMath::Sqrt(cl->GetQ())*6;
Int_t row = row0+ddrow*delta;
kr = &(fSectors[sec][row]);
Double_t xn = kr->GetX();
- Double_t ymax = fSectors->GetMaxY(row)-kr->fDeadZone-1.5;
+ Double_t ymax = fSectors->GetMaxY(row)-kr->GetDeadZone()-1.5;
polytrack.GetFitPoint(xn,yn,zn);
if (TMath::Abs(yn)>ymax) continue;
nfoundable++;
UInt_t index=0;
//kr0.GetIndex(is);
- AliTPCseed *track=new (seed) AliTPCseed(index, x, c, x1, sec*alpha+shift);
- track->fIsSeeding = kTRUE;
+ AliTPCseed *track=new (seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
+ track->SetIsSeeding(kTRUE);
Int_t rc=FollowProlongation(*track, i2);
- if (constrain) track->fBConstrain =1;
+ if (constrain) track->SetBConstrain(1);
else
- track->fBConstrain =0;
- track->fLastPoint = row1+fInnerSec->GetNRows(); // first cluster in track position
- track->fFirstPoint = track->fLastPoint;
+ track->SetBConstrain(0);
+ track->SetLastPoint(row1+fInnerSec->GetNRows()); // first cluster in track position
+ track->SetFirstPoint(track->GetLastPoint());
if (rc==0 || track->GetNumberOfClusters()<(i1-i2)*0.5 ||
- track->GetNumberOfClusters() < track->fNFoundable*0.6 ||
- track->fNShared>0.4*track->GetNumberOfClusters()) {
+ track->GetNumberOfClusters() < track->GetNFoundable()*0.6 ||
+ track->GetNShared()>0.4*track->GetNumberOfClusters()) {
//delete track;
seed->Reset();
seed->~AliTPCseed();
Int_t p2 = int(r2*track->GetNumberOfClusters()); // last point
Int_t pp2=0;
Double_t x0[3],x1[3],x2[3];
- x0[0]=-1;
- x0[0]=-1;
- x0[0]=-1;
+ for (Int_t i=0;i<3;i++){
+ x0[i]=-1;
+ x1[i]=-1;
+ x2[i]=-1;
+ }
// find track position at given ratio of the length
- Int_t sec0, sec1, sec2;
- sec0=0;
- sec1=0;
- sec2=0;
+ Int_t sec0=0, sec1=0, sec2=0;
Int_t index=-1;
Int_t clindex;
for (Int_t i=0;i<160;i++){
- if (track->fClusterPointer[i]){
+ if (track->GetClusterPointer(i)){
index++;
AliTPCTrackerPoint *trpoint =track->GetTrackPoint(i);
if ( (index<p0) || x0[0]<0 ){
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(x2[0]);
- AliTPCseed *seed=new AliTPCseed(0, x, c, x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift());
+ AliTPCseed *seed=new AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
// Double_t y0,z0,y1,z1, y2,z2;
//seed->GetProlongation(x0[0],y0,z0);
// seed->GetProlongation(x1[0],y1,z1);
//seed->GetProlongation(x2[0],y2,z2);
// seed =0;
- seed->fLastPoint = pp2;
- seed->fFirstPoint = pp2;
+ seed->SetLastPoint(pp2);
+ seed->SetFirstPoint(pp2);
return seed;
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
- AliTPCseed *seed=new AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift());
- seed->fLastPoint = row[2];
- seed->fFirstPoint = row[2];
+ AliTPCseed *seed=new AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ seed->SetLastPoint(row[2]);
+ seed->SetFirstPoint(row[2]);
return seed;
}
//reseed using founded clusters
//
Double_t xyz[3][3];
- Int_t row[3]={0,0,0},sec[3]={0,0,0};
+ Int_t row[3]={0,0,0};
+ Int_t sec[3]={0,0,0};
//
// forward direction
if (forward){
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
- AliTPCseed *seed=new AliTPCseed(0, x, c, xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift());
- seed->fLastPoint = row[2];
- seed->fFirstPoint = row[2];
+ AliTPCseed *seed=new AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ seed->SetLastPoint(row[2]);
+ seed->SetFirstPoint(row[2]);
for (Int_t i=row[0];i<row[2];i++){
- seed->fIndex[i] = track->fIndex[i];
+ seed->SetClusterIndex(i, track->GetClusterIndex(i));
}
return seed;
Int_t *sign = new Int_t[nentries];
Int_t *nclusters = new Int_t[nentries];
Float_t *alpha = new Float_t[nentries];
- AliESDkink * kink = new AliESDkink();
+ AliKink *kink = new AliKink();
Int_t * usage = new Int_t[nentries];
Float_t *zm = new Float_t[nentries];
Float_t *z0 = new Float_t[nentries];
usage[i]=0;
AliTPCseed* track = (AliTPCseed*)array->At(i);
if (!track) continue;
- track->fCircular =0;
+ track->SetCircular(0);
shared[i] = kFALSE;
track->UpdatePoints();
if (( track->GetPoints()[2]- track->GetPoints()[0])>5 && track->GetPoints()[3]>0.8){
for (Int_t i0=0;i0<nentries;i0++){
AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
if (!track0) continue;
- if (track0->fN<40) continue;
- if (TMath::Abs(1./track0->fP4)>200) continue;
+ if (track0->GetNumberOfClusters()<40) continue;
+ if (TMath::Abs(1./track0->GetC())>200) continue;
for (Int_t i1=i0+1;i1<nentries;i1++){
AliTPCseed * track1 = (AliTPCseed*)array->At(i1);
if (!track1) continue;
- if (track1->fN<40) continue;
- if ( TMath::Abs(track1->fP3+track0->fP3)>0.1) continue;
- if (track0->fBConstrain&&track1->fBConstrain) continue;
- if (TMath::Abs(1./track1->fP4)>200) continue;
- if (track1->fP4*track0->fP4>0) continue;
- if (track1->fP3*track0->fP3>0) continue;
- if (max(TMath::Abs(1./track0->fP4),TMath::Abs(1./track1->fP4))>190) continue;
- if (track0->fBConstrain&&TMath::Abs(track1->fP4)<TMath::Abs(track0->fP4)) continue; //returning - lower momenta
- if (track1->fBConstrain&&TMath::Abs(track0->fP4)<TMath::Abs(track1->fP4)) continue; //returning - lower momenta
+ if (track1->GetNumberOfClusters()<40) continue;
+ if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
+ if (track0->GetBConstrain()&&track1->GetBConstrain()) continue;
+ if (TMath::Abs(1./track1->GetC())>200) continue;
+ if (track1->Get1Pt()*track0->Get1Pt()>0) continue;
+ if (track1->GetTgl()*track0->GetTgl()>0) continue;
+ if (max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue;
+ if (track0->GetBConstrain()&&TMath::Abs(track1->Get1Pt())<TMath::Abs(track0->Get1Pt())) continue; //returning - lower momenta
+ if (track1->GetBConstrain()&&TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())) continue; //returning - lower momenta
//
Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1]));
if (mindcar<5) continue;
if (sign){
circular[i0] = kTRUE;
circular[i1] = kTRUE;
- if (TMath::Abs(track0->fP4)<TMath::Abs(track1->fP4)){
- track0->fCircular += 1;
- track1->fCircular += 2;
+ if (TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())){
+ track0->SetCircular(track0->GetCircular()+1);
+ track1->SetCircular(track1->GetCircular()+2);
}
else{
- track1->fCircular += 1;
- track0->fCircular += 2;
+ track1->SetCircular(track1->GetCircular()+1);
+ track0->SetCircular(track0->GetCircular()+2);
}
}
- if (sign){
- //debug stream
+ if (sign&&AliTPCReconstructor::StreamLevel()>1){
+ //debug stream
+ Int_t lab0=track0->GetLabel();
+ Int_t lab1=track1->GetLabel();
cstream<<"Curling"<<
- "lab0="<<track0->fLab<<
- "lab1="<<track1->fLab<<
+ "lab0="<<lab0<<
+ "lab1="<<lab1<<
"Tr0.="<<track0<<
"Tr1.="<<track1<<
"dca0="<<dca[i0]<<
if (TMath::Abs(ktrack0->GetC())>5) continue; // cut on the curvature for mother particle
AliExternalTrackParam paramm(*ktrack0);
AliExternalTrackParam paramd(*ktrack1);
- if (row0>60&&ktrack1->GetReference().X()>90.) new (¶md) AliExternalTrackParam(ktrack1->GetReference());
+ if (row0>60&&ktrack1->GetReference().GetX()>90.) new (¶md) AliExternalTrackParam(ktrack1->GetReference());
//
//
kink->SetMother(paramm);
if (mpt<1){
//for high momenta momentum not defined well in first iteration
- Double_t qt = TMath::Sin(kink->GetAngle(2))*ktrack1->P();
+ Double_t qt = TMath::Sin(kink->GetAngle(2))*ktrack1->GetP();
if (qt>0.35) continue;
}
// angle and densities not defined yet
if (kink->GetTPCDensityFactor()<0.8) continue;
if ((2-kink->GetTPCDensityFactor())*kink->GetDistance() >0.25) continue;
- if (kink->GetAngle(2)*ktrack0->P()<0.003) continue; //too small angle
+ if (kink->GetAngle(2)*ktrack0->GetP()<0.003) continue; //too small angle
if (kink->GetAngle(2)>0.2&&kink->GetTPCDensityFactor()<1.15) continue;
if (kink->GetAngle(2)>0.2&&kink->GetTPCDensity(0,1)>0.05) continue;
- Float_t criticalangle = track0->fC22+track0->fC33;
- criticalangle+= track1->fC22+track1->fC33;
+ Float_t criticalangle = track0->GetSigmaSnp2()+track0->GetSigmaTgl2();
+ criticalangle+= track1->GetSigmaSnp2()+track1->GetSigmaTgl2();
criticalangle= 3*TMath::Sqrt(criticalangle);
if (criticalangle>0.02) criticalangle=0.02;
if (kink->GetAngle(2)<criticalangle) continue;
for ( Int_t row = row0-drow; row<row0+drow;row++){
if (row<0) continue;
if (row>155) continue;
- if (ktrack0->fClusterPointer[row]){
+ if (ktrack0->GetClusterPointer(row)){
AliTPCTrackerPoint *point =ktrack0->GetTrackPoint(row);
shapesum+=point->GetSigmaY()+point->GetSigmaZ();
sum++;
}
- if (ktrack1->fClusterPointer[row]){
+ if (ktrack1->GetClusterPointer(row)){
AliTPCTrackerPoint *point =ktrack1->GetTrackPoint(row);
shapesum+=point->GetSigmaY()+point->GetSigmaZ();
sum++;
}
// esd->AddKink(kink);
kinks->AddLast(kink);
- kink = new AliESDkink;
+ kink = new AliKink;
ncandidates++;
}
}
//
for (Int_t i=0;i<nkinks;i++){
quality[i] =100000;
- AliESDkink *kink = (AliESDkink*)kinks->At(i);
+ AliKink *kink = (AliKink*)kinks->At(i);
//
// refit kinks towards vertex
//
AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
//
- Int_t sumn=ktrack0->fN+ktrack1->fN;
+ Int_t sumn=ktrack0->GetNumberOfClusters()+ktrack1->GetNumberOfClusters();
//
// Refit Kink under if too small angle
//
//
Int_t last = row0-drow;
if (last<40) last=40;
- if (last<ktrack0->fFirstPoint+25) last = ktrack0->fFirstPoint+25;
+ if (last<ktrack0->GetFirstPoint()+25) last = ktrack0->GetFirstPoint()+25;
AliTPCseed* seed0 = ReSeed(ktrack0,last,kFALSE);
//
//
Int_t first = row0+drow;
if (first>130) first=130;
- if (first>ktrack1->fLastPoint-25) first = TMath::Max(ktrack1->fLastPoint-25,30);
+ if (first>ktrack1->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30);
AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE);
//
if (seed0 && seed1){
kink->SetStatus(1,8);
if (RefitKink(*seed0,*seed1,*kink)) kink->SetStatus(1,9);
row0 = GetRowNumber(kink->GetR());
- sumn = seed0->fN+seed1->fN;
+ sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
new (&mothers[i]) AliTPCseed(*seed0);
new (&daughters[i]) AliTPCseed(*seed1);
}
//remove double find kinks
//
for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
- AliESDkink * kink0 = (AliESDkink*) kinks->At(indexes[ikink0]);
+ AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
if (!kink0) continue;
//
for (Int_t ikink1=0;ikink1<ikink0;ikink1++){
if (!kink0) continue;
- AliESDkink * kink1 = (AliESDkink*) kinks->At(indexes[ikink1]);
+ AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]);
if (!kink1) continue;
// if not close kink continue
if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue;
Int_t bothd = 0;
//
for (Int_t i=0;i<row0;i++){
- if (mother0.fIndex[i]>0 && mother1.fIndex[i]>0){
+ if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){
both++;
bothm++;
- if (mother0.fIndex[i]==mother1.fIndex[i]){
+ if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
same++;
samem++;
}
}
for (Int_t i=row0;i<158;i++){
- if (daughter0.fIndex[i]>0 && daughter0.fIndex[i]>0){
+ if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){
both++;
bothd++;
- if (mother0.fIndex[i]==mother1.fIndex[i]){
+ if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
same++;
samed++;
}
Float_t ratiom = Float_t(samem+1)/Float_t(bothm+1);
Float_t ratiod = Float_t(samed+1)/Float_t(bothd+1);
if (ratio>0.3 && ratiom>0.5 &&ratiod>0.5) {
- Int_t sum0 = mother0.fN+daughter0.fN;
- Int_t sum1 = mother1.fN+daughter1.fN;
+ Int_t sum0 = mother0.GetNumberOfClusters()+daughter0.GetNumberOfClusters();
+ Int_t sum1 = mother1.GetNumberOfClusters()+daughter1.GetNumberOfClusters();
if (sum1>sum0){
shared[kink0->GetIndex(0)]= kTRUE;
shared[kink0->GetIndex(1)]= kTRUE;
for (Int_t i=0;i<nkinks;i++){
- AliESDkink * kink = (AliESDkink*) kinks->At(indexes[i]);
+ AliKink * kink = (AliKink*) kinks->At(indexes[i]);
if (!kink) continue;
kink->SetTPCRow0(GetRowNumber(kink->GetR()));
Int_t index0 = kink->GetIndex(0);
Int_t index = esd->AddKink(kink);
//
//
- if ( ktrack0->fKinkIndexes[0]==0 && ktrack1->fKinkIndexes[0]==0) { //best kink
- if (mothers[indexes[i]].fN>20 && daughters[indexes[i]].fN>20 && (mothers[indexes[i]].fN+daughters[indexes[i]].fN)>100){
+ if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink
+ if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){
new (ktrack0) AliTPCseed(mothers[indexes[i]]);
new (ktrack1) AliTPCseed(daughters[indexes[i]]);
}
}
//
- ktrack0->fKinkIndexes[usage[index0]] = -(index+1);
- ktrack1->fKinkIndexes[usage[index1]] = (index+1);
+ ktrack0->SetKinkIndex(usage[index0],-(index+1));
+ ktrack1->SetKinkIndex(usage[index1], (index+1));
usage[index0]++;
usage[index1]++;
}
for (Int_t i=0;i<nentries;i++){
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
- if (track0->fKinkIndexes[0]!=0) continue;
+ if (track0->GetKinkIndex(0)!=0) continue;
if (shared[i]) delete array->RemoveAt(i);
}
for (Int_t i=0;i<nentries;i++){
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
- if (track0->Pt()<1.4) continue;
+ if (track0->GetPt()<1.4) continue;
//remove double high momenta tracks - overlapped with kink candidates
Int_t shared=0;
Int_t all =0;
- for (Int_t icl=track0->fFirstPoint;icl<track0->fLastPoint; icl++){
- if (track0->fClusterPointer[icl]!=0){
+ for (Int_t icl=track0->GetFirstPoint();icl<track0->GetLastPoint(); icl++){
+ if (track0->GetClusterPointer(icl)!=0){
all++;
- if (track0->fClusterPointer[icl]->IsUsed(10)) shared++;
+ if (track0->GetClusterPointer(icl)->IsUsed(10)) shared++;
}
}
if (Float_t(shared+1)/Float_t(nall+1)>0.5) {
delete array->RemoveAt(i);
+ continue;
}
//
- if (track0->fKinkIndexes[0]!=0) continue;
+ if (track0->GetKinkIndex(0)!=0) continue;
if (track0->GetNumberOfClusters()<80) continue;
- AliTPCseed mother;
- AliTPCseed daughter;
- AliESDkink kink;
+
+ AliTPCseed *pmother = new AliTPCseed();
+ AliTPCseed *pdaughter = new AliTPCseed();
+ AliKink *pkink = new AliKink;
+
+ AliTPCseed & mother = *pmother;
+ AliTPCseed & daughter = *pdaughter;
+ AliKink & kink = *pkink;
if (CheckKinkPoint(track0,mother,daughter, kink)){
- if (mother.fN<30||daughter.fN<20) continue; //too short tracks
- if (mother.Pt()<1.4) continue;
+ if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) {
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
+ continue; //too short tracks
+ }
+ if (mother.GetPt()<1.4) {
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
+ continue;
+ }
Int_t row0= kink.GetTPCRow0();
if (kink.GetDistance()>0.5 || kink.GetR()<110. || kink.GetR()>240.) {
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
continue;
}
//
Int_t index = esd->AddKink(&kink);
- mother.fKinkIndexes[0] = -(index+1);
- daughter.fKinkIndexes[0] = index+1;
- if (mother.fN>50) {
+ mother.SetKinkIndex(0,-(index+1));
+ daughter.SetKinkIndex(0,index+1);
+ if (mother.GetNumberOfClusters()>50) {
delete array->RemoveAt(i);
array->AddAt(new AliTPCseed(mother),i);
}
}
array->AddLast(new AliTPCseed(daughter));
for (Int_t icl=0;icl<row0;icl++) {
- if (mother.fClusterPointer[icl]) mother.fClusterPointer[icl]->Use(20);
+ if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20);
}
//
for (Int_t icl=row0;icl<158;icl++) {
- if (daughter.fClusterPointer[icl]) daughter.fClusterPointer[icl]->Use(20);
+ if (daughter.GetClusterPointer(icl)) daughter.GetClusterPointer(icl)->Use(20);
}
//
}
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
}
delete [] daughters;
//
// dca error parrameterezation + pulls
//
- sdcar[i] = TMath::Sqrt(0.150*0.150+(100*track->fP4)*(100*track->fP4));
- if (TMath::Abs(track->fP3)>1) sdcar[i]*=2.5;
- cdcar[i] = TMath::Exp((TMath::Abs(track->fP4)-0.0106)*525.3);
+ sdcar[i] = TMath::Sqrt(0.150*0.150+(100*track->GetC())*(100*track->GetC()));
+ if (TMath::Abs(track->GetTgl())>1) sdcar[i]*=2.5;
+ cdcar[i] = TMath::Exp((TMath::Abs(track->GetC())-0.0106)*525.3);
pulldcar[i] = (dca[i]-cdcar[i])/sdcar[i];
pulldcaz[i] = (z0[i]-zvertex)/sdcar[i];
pulldca[i] = TMath::Sqrt(pulldcar[i]*pulldcar[i]+pulldcaz[i]*pulldcaz[i]);
- if (track->fTPCr[1]+track->fTPCr[2]+track->fTPCr[3]>0.5) {
+ if (track->TPCrPID(1)+track->TPCrPID(2)+track->TPCrPID(3)>0.5) {
if (pulldca[i]<3.) isPrim[i]=kTRUE; //pion, muon and Kaon 3 sigma cut
}
- if (track->fTPCr[4]>0.5) {
+ if (track->TPCrPID(4)>0.5) {
if (pulldca[i]<0.5) isPrim[i]=kTRUE; //proton 0.5 sigma cut
}
- if (track->fTPCr[0]>0.4) {
+ if (track->TPCrPID(0)>0.4) {
isPrim[i]=kFALSE; //electron no sigma cut
}
}
// //
TTreeSRedirector &cstream = *fDebugStreamer;
Float_t fprimvertex[3]={GetX(),GetY(),GetZ()};
- AliESDV0MI vertex;
+ AliV0 vertex;
Double_t cradius0 = 10*10;
Double_t cradius1 = 200*200;
Double_t cdist1=3.;
if (sign[i]==0) continue;
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
- cstream<<"Tracks"<<
- "Tr0.="<<track0<<
- "dca="<<dca[i]<<
- "z0="<<z0[i]<<
- "zvertex="<<zvertex<<
- "sdcar0="<<sdcar[i]<<
- "cdcar0="<<cdcar[i]<<
- "pulldcar0="<<pulldcar[i]<<
- "pulldcaz0="<<pulldcaz[i]<<
- "pulldca0="<<pulldca[i]<<
- "isPrim="<<isPrim[i]<<
- "\n";
+ if (AliTPCReconstructor::StreamLevel()>0){
+ cstream<<"Tracks"<<
+ "Tr0.="<<track0<<
+ "dca="<<dca[i]<<
+ "z0="<<z0[i]<<
+ "zvertex="<<zvertex<<
+ "sdcar0="<<sdcar[i]<<
+ "cdcar0="<<cdcar[i]<<
+ "pulldcar0="<<pulldcar[i]<<
+ "pulldcaz0="<<pulldcaz[i]<<
+ "pulldca0="<<pulldca[i]<<
+ "isPrim="<<isPrim[i]<<
+ "\n";
+ }
//
- if (track0->fP4<0) continue;
+ if (track0->Get1Pt()<0) continue;
if (track0->GetKinkIndex(0)>0||isPrim[i]) continue; //daughter kink
//
if (TMath::Abs(helixes[i].GetHelix(4))<0.000000001) 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->fCircular+track1->fCircular>1) continue; //circling -returning track
+ if (track0->GetCircular()+track1->GetCircular()>1) continue; //circling -returning track
nall++;
//
// DCA to prim vertex cut
if (pointAngle<cpointAngle) continue;
//
Bool_t isGamma = kFALSE;
- vertex.SetP(*track0); //track0 - plus
- vertex.SetM(*track1); //track1 - minus
+ vertex.SetParamP(*track0); //track0 - plus
+ vertex.SetParamN(*track1); //track1 - minus
vertex.Update(fprimvertex);
- if (track0->fTPCr[0]>0.3&&track1->fTPCr[0]>0.3&&vertex.GetAnglep()[2]<0.15) isGamma=kTRUE; // gamma conversion candidate
- Double_t pointAngle2 = vertex.GetPointAngle();
+ if (track0->TPCrPID(0)>0.3&&track1->TPCrPID(0)>0.3&&vertex.GetAnglep()[2]<0.15) isGamma=kTRUE; // gamma conversion candidate
+ Double_t pointAngle2 = vertex.GetV0CosineOfPointingAngle();
//continue;
- if (vertex.GetPointAngle()<cpointAngle && (!isGamma)) continue; // point angle cut
- if (vertex.GetDist2()>2&&(!isGamma)) continue; // point angle cut
+ if (vertex.GetV0CosineOfPointingAngle()<cpointAngle && (!isGamma)) continue;// point angle cut
+ //Bo: if (vertex.GetDist2()>2&&(!isGamma)) continue; // point angle cut
+ if (vertex.GetDcaV0Daughters()>2&&(!isGamma)) continue;//Bo: // point angle cut
Float_t sigmae = 0.15*0.15;
if (vertex.GetRr()<80)
sigmae += (sdcar[i]*sdcar[i]+sdcar[j]*sdcar[j])*(1.-vertex.GetRr()/80.)*(1.-vertex.GetRr()/80.);
sigmae+= TMath::Sqrt(sigmae);
- if (vertex.GetDist2()/sigmae>3.&&(!isGamma)) continue;
+ //Bo: if (vertex.GetDist2()/sigmae>3.&&(!isGamma)) continue;
+ if (vertex.GetDcaV0Daughters()/sigmae>3.&&(!isGamma)) continue;
Float_t densb0=0,densb1=0,densa0=0,densa1=0;
Int_t row0 = GetRowNumber(vertex.GetRr());
if (row0>15){
- if (vertex.GetDist2()>0.2) continue;
+ //Bo: if (vertex.GetDist2()>0.2) continue;
+ if (vertex.GetDcaV0Daughters()>0.2) continue;
densb0 = track0->Density2(0,row0-5);
densb1 = track1->Density2(0,row0-5);
if (densb0>0.3|| densb1>0.3) continue; //clusters before vertex
densa1 = track1->Density2(0,40); //cluster density
if ((vertex.GetRr()<80&&densa0+densa1<1.)&&(!isGamma)) continue;
}
- vertex.SetLab(0,track0->GetLabel());
- vertex.SetLab(1,track1->GetLabel());
+//Bo: vertex.SetLab(0,track0->GetLabel());
+//Bo: vertex.SetLab(1,track1->GetLabel());
vertex.SetChi2After((densa0+densa1)*0.5);
vertex.SetChi2Before((densb0+densb1)*0.5);
vertex.SetIndex(0,i);
vertex.SetIndex(1,j);
- vertex.SetStatus(1); // TPC v0 candidate
- vertex.SetRp(track0->fTPCr);
- vertex.SetRm(track1->fTPCr);
- tpcv0s->AddLast(new AliESDV0MI(vertex));
+//Bo: vertex.SetStatus(1); // TPC v0 candidate
+ vertex.SetOnFlyStatus(2);//Bo: // TPC v0 candidate
+//Bo: vertex.SetRp(track0->TPCrPIDs());
+//Bo: vertex.SetRm(track1->TPCrPIDs());
+ tpcv0s->AddLast(new AliESDv0(vertex));
ncandidates++;
{
Int_t eventNr = esd->GetEventNumber();
Double_t radiusm= (delta[0]<delta[1])? TMath::Sqrt(radius[0]):TMath::Sqrt(radius[1]);
Double_t deltam= (delta[0]<delta[1])? TMath::Sqrt(delta[0]):TMath::Sqrt(delta[1]);
- cstream<<"V0"<<
+ if (AliTPCReconstructor::StreamLevel()>0) {
+ Int_t lab0=track0->GetLabel();
+ Int_t lab1=track1->GetLabel();
+ Char_t c0=track0->GetCircular();
+ Char_t c1=track1->GetCircular();
+ cstream<<"V0"<<
"Event="<<eventNr<<
"vertex.="<<&vertex<<
"Tr0.="<<track0<<
- "lab0="<<track0->fLab<<
+ "lab0="<<lab0<<
"Helix0.="<<&helixes[i]<<
"Tr1.="<<track1<<
- "lab1="<<track1->fLab<<
+ "lab1="<<lab1<<
"Helix1.="<<&helixes[j]<<
"pointAngle="<<pointAngle<<
"pointAngle2="<<pointAngle2<<
"z0="<<z0[i]<<
"z1="<<z0[j]<<
"zvertex="<<zvertex<<
- "circular0="<<track0->fCircular<<
- "circular1="<<track1->fCircular<<
+ "circular0="<<c0<<
+ "circular1="<<c1<<
"npoints="<<npoints<<
"radius0="<<radius[0]<<
"delta0="<<delta[0]<<
"densa0="<<densa0<<
"densa1="<<densa1<<
"sigmae="<<sigmae<<
- "\n";
+ "\n";}
}
}
}
Int_t naccepted =0;
for (Int_t i=0;i<ncandidates;i++){
quality[i] = 0;
- AliESDV0MI *v0 = (AliESDV0MI*)tpcv0s->At(i);
- quality[i] = 1./(1.00001-v0->GetPointAngle()); //base point angle
+ AliESDv0 *v0 = (AliESDv0*)tpcv0s->At(i);
+ quality[i] = 1./(1.00001-v0->GetV0CosineOfPointingAngle()); //base point angle
// quality[i] /= (0.5+v0->GetDist2());
// quality[i] *= v0->GetChi2After(); //density factor
- Double_t minpulldca = TMath::Min(2.+pulldca[v0->GetIndex(0)],(2.+pulldca[v0->GetIndex(1)]) ); //pull
+
Int_t index0 = v0->GetIndex(0);
Int_t index1 = v0->GetIndex(1);
+ //Bo: Double_t minpulldca = TMath::Min(2.+pulldca[v0->GetIndex(0)],(2.+pulldca[v0->GetIndex(1)]) ); //pull
+ Double_t minpulldca = TMath::Min(2.+pulldca[index0],(2.+pulldca[index1]) );//Bo:
+
+
+
AliTPCseed * track0 = (AliTPCseed*)array->At(index0);
AliTPCseed * track1 = (AliTPCseed*)array->At(index1);
- if (track0->fTPCr[0]>0.3&&track1->fTPCr[0]>0.3&&v0->GetAnglep()[2]<0.15) quality[i]+=1000000; // gamma conversion candidate
- if (track0->fTPCr[4]>0.9||track1->fTPCr[4]>0.9&&minpulldca>4) quality[i]*=10; // lambda candidate candidate
+ if (track0->TPCrPID(0)>0.3&&track1->TPCrPID(0)>0.3&&v0->GetAnglep()[2]<0.15) quality[i]+=1000000; // gamma conversion candidate
+ if (track0->TPCrPID(4)>0.9||track1->TPCrPID(4)>0.9&&minpulldca>4) quality[i]*=10; // lambda candidate candidate
}
TMath::Sort(ncandidates,quality,indexes,kTRUE);
//
//
for (Int_t i=0;i<ncandidates;i++){
- AliESDV0MI * v0 = (AliESDV0MI*)tpcv0s->At(indexes[i]);
+ AliESDv0 * v0 = (AliESDv0*)tpcv0s->At(indexes[i]);
if (!v0) continue;
Int_t index0 = v0->GetIndex(0);
Int_t index1 = v0->GetIndex(1);
if (v0indexes0[2]!=0) {order0=3; accept=kFALSE;}
if (v0indexes0[2]!=0) {order1=3; accept=kFALSE;}
//
- AliESDV0MI * v02 = v0;
+ AliESDv0 * v02 = v0;
if (accept){
- v0->SetOrder(0,order0);
- v0->SetOrder(1,order1);
- v0->SetOrder(1,order0+order1);
- Int_t index = esd->AddV0MI(v0);
- v02 = esd->GetV0MI(index);
+ //Bo: v0->SetOrder(0,order0);
+ //Bo: v0->SetOrder(1,order1);
+ //Bo: v0->SetOrder(1,order0+order1);
+ v0->SetOnFlyStatus(kTRUE);
+ Int_t index = esd->AddV0(v0);
+ v02 = esd->GetV0(index);
v0indexes0[order0]=index;
v0indexes1[order1]=index;
naccepted++;
}
{
Int_t eventNr = esd->GetEventNumber();
- cstream<<"V02"<<
+ if (AliTPCReconstructor::StreamLevel()>0) {
+ Int_t lab0=track0->GetLabel();
+ Int_t lab1=track1->GetLabel();
+ cstream<<"V02"<<
"Event="<<eventNr<<
"vertex.="<<v0<<
"vertex2.="<<v02<<
"Tr0.="<<track0<<
- "lab0="<<track0->fLab<<
+ "lab0="<<lab0<<
"Tr1.="<<track1<<
- "lab1="<<track1->fLab<<
+ "lab1="<<lab1<<
"dca0="<<dca[index0]<<
"dca1="<<dca[index1]<<
"order0="<<order0<<
"pulldca0="<<pulldca[index0]<<
"pulldca1="<<pulldca[index1]<<
"index="<<i<<
- "\n";
+ "\n";}
}
}
timer.Print();
}
-Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink)
+Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
{
//
// refit kink towards to the vertex
//
//
+ AliKink &kink=(AliKink &)knk;
+
Int_t row0 = GetRowNumber(kink.GetR());
FollowProlongation(mother,0);
mother.Reset(kFALSE);
const Int_t kNdiv =5;
AliTPCseed param0[kNdiv]; // parameters along the track
AliTPCseed param1[kNdiv]; // parameters along the track
- AliESDkink kinks[kNdiv]; // corresponding kink parameters
+ AliKink kinks[kNdiv]; // corresponding kink parameters
//
Int_t rows[kNdiv];
for (Int_t irow=0; irow<kNdiv;irow++){
//
// define kinks
for (Int_t irow=0; irow<kNdiv-1;irow++){
- if (param0[irow].fN<kNdiv||param1[irow].fN<kNdiv) continue;
+ if (param0[irow].GetNumberOfClusters()<kNdiv||param1[irow].GetNumberOfClusters()<kNdiv) continue;
kinks[irow].SetMother(param0[irow]);
kinks[irow].SetDaughter(param1[irow]);
kinks[irow].Update();
Int_t index =-1;
Double_t mindist = 10000;
for (Int_t irow=0;irow<kNdiv;irow++){
- if (param0[irow].fN<20||param1[irow].fN<20) continue;
+ if (param0[irow].GetNumberOfClusters()<20||param1[irow].GetNumberOfClusters()<20) continue;
if (TMath::Abs(kinks[irow].GetR())>240.) continue;
if (TMath::Abs(kinks[irow].GetR())<100.) continue;
//
- Float_t normdist = TMath::Abs(param0[irow].fX-kinks[irow].GetR())*(0.1+kink.GetDistance());
- normdist/= (param0[irow].fN+param1[irow].fN+40.);
+ Float_t normdist = TMath::Abs(param0[irow].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance());
+ normdist/= (param0[irow].GetNumberOfClusters()+param1[irow].GetNumberOfClusters()+40.);
if (normdist < mindist){
mindist = normdist;
index = irow;
kink.SetDaughter(daughter);
kink.Update();
kink.SetTPCRow0(GetRowNumber(kink.GetR()));
- kink.SetTPCncls(param0[index].fN,0);
- kink.SetTPCncls(param1[index].fN,1);
+ kink.SetTPCncls(param0[index].GetNumberOfClusters(),0);
+ kink.SetTPCncls(param1[index].GetNumberOfClusters(),1);
kink.SetLabel(CookLabel(&mother,0.4, 0,kink.GetTPCRow0()),0);
kink.SetLabel(CookLabel(&daughter,0.4, kink.GetTPCRow0(),160),1);
mother.SetLabel(kink.GetLabel(0));
}
-Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &kink)
+Int_t AliTPCtrackerMI::CheckKinkPoint(AliTPCseed*seed,AliTPCseed &mother, AliTPCseed &daughter, AliESDkink &knk)
{
//
// check kink point for given track
// otherwise seed0 correspond to mother particle
// seed1 correspond to daughter particle
// kink parameter of kink point
+ AliKink &kink=(AliKink &)knk;
- Int_t middlerow = (seed->fFirstPoint+seed->fLastPoint)/2;
- Int_t first = seed->fFirstPoint;
- Int_t last = seed->fLastPoint;
+ Int_t middlerow = (seed->GetFirstPoint()+seed->GetLastPoint())/2;
+ Int_t first = seed->GetFirstPoint();
+ Int_t last = seed->GetLastPoint();
if (last-first<20) return 0; // shortest length - 2*30 = 60 pad-rows
AliTPCseed *seed1 = ReSeed(seed,middlerow+20, kTRUE); //middle of chamber
if (!seed1) return 0;
- FollowProlongation(*seed1,seed->fLastPoint-20);
+ FollowProlongation(*seed1,seed->GetLastPoint()-20);
seed1->Reset(kTRUE);
FollowProlongation(*seed1,158);
seed1->Reset(kTRUE);
- last = seed1->fLastPoint;
+ last = seed1->GetLastPoint();
//
AliTPCseed *seed0 = new AliTPCseed(*seed);
seed0->Reset(kFALSE);
//
AliTPCseed param0[20]; // parameters along the track
AliTPCseed param1[20]; // parameters along the track
- AliESDkink kinks[20]; // corresponding kink parameters
+ AliKink kinks[20]; // corresponding kink parameters
Int_t rows[20];
for (Int_t irow=0; irow<20;irow++){
rows[irow] = first +((last-first)*irow)/19;
for (Int_t irow=1;irow<19;irow++){
if (TMath::Abs(kinks[irow].GetR())>240.) continue;
if (TMath::Abs(kinks[irow].GetR())<110.) continue;
- Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX));
+ Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
if ( quality > maxchange){
maxchange = quality;
index = irow;
seed1 = new AliTPCseed(param1[index]);
seed0->Reset(kFALSE);
seed1->Reset(kFALSE);
- seed0->ResetCovariance();
- seed1->ResetCovariance();
+ seed0->ResetCovariance(10.);
+ seed1->ResetCovariance(10.);
FollowProlongation(*seed0,0);
FollowBackProlongation(*seed1,158);
new (&mother) AliTPCseed(*seed0); // backup mother at position 0
seed0->Reset(kFALSE);
seed1->Reset(kFALSE);
- seed0->ResetCovariance();
- seed1->ResetCovariance();
+ seed0->ResetCovariance(10.);
+ seed1->ResetCovariance(10.);
//
first = TMath::Max(row0-20,0);
last = TMath::Min(row0+20,158);
for (Int_t irow=0;irow<20;irow++){
if (TMath::Abs(kinks[irow].GetR())>250.) continue;
if (TMath::Abs(kinks[irow].GetR())<90.) continue;
- Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].fX));
+ Float_t quality = TMath::Abs(kinks[irow].GetAngle(2))/(3.+TMath::Abs(kinks[irow].GetR()-param0[irow].GetX()));
if ( quality > maxchange){
maxchange = quality;
index = irow;
}
//
//
- if (index==-1 || param0[index].fN+param1[index].fN<100){
+ if (index==-1 || param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()<100){
delete seed0;
delete seed1;
return 0;
kink.SetLabel(CookLabel(seed0,0.5,0,row0),0);
kink.SetLabel(CookLabel(seed1,0.5,row0,158),1);
kink.SetIndex(-10,0);
- kink.SetIndex(int(param0[index].fN+param1[index].fN),1);
- kink.SetTPCncls(param0[index].fN,0);
- kink.SetTPCncls(param1[index].fN,1);
+ kink.SetIndex(int(param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()),1);
+ kink.SetTPCncls(param0[index].GetNumberOfClusters(),0);
+ kink.SetTPCncls(param1[index].GetNumberOfClusters(),1);
//
//
// new (&mother) AliTPCseed(param0[index]);
// Int_t last = fSectors->GetNRows()-1;
//
if (fSectors == fOuterSec){
- first = TMath::Max(first, t->fFirstPoint-fInnerSec->GetNRows());
+ first = TMath::Max(first, t->GetFirstPoint()-fInnerSec->GetNRows());
//last =
}
else
- first = t->fFirstPoint;
+ first = t->GetFirstPoint();
//
AliTPCseed * seed = MakeSeed(t,0.1,0.5,0.9);
FollowBackProlongation(*t,fSectors->GetNRows()-1);
continue;
}
CookLabel(pt,0.1);
- if (pt->fRemoval==10) {
+ if (pt->GetRemoval()==10) {
if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
pt->Desactivate(10); // make track again active
else{
}
//
RemoveUsed2(fSeeds,0.85,0.85,0);
- FindKinks(fSeeds,fEvent);
+ if (AliTPCReconstructor::GetRecoParam()->GetDoKinks()) FindKinks(fSeeds,fEvent);
RemoveUsed2(fSeeds,0.5,0.4,20);
// //
// // refit short tracks
}
CookLabel(pt,0.1); //For comparison only
//if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){
- if ((pt->IsActive() || (pt->fRemoval==10) )){
+ if ((pt->IsActive() || (pt->GetRemoval()==10) )){
found++;
if (fDebug>0) cerr<<found<<'\r';
- pt->fLab2 = i;
+ pt->SetLab2(i);
}
else
delete fSeeds->RemoveAt(i);
t.CookdEdx(0.02,0.6);
// CheckKinkPoint(&t,0.05);
//if ((pt->IsActive() || (pt->fRemoval==10) )&& nc>50 &&pt->GetNumberOfClusters()>0.4*pt->fNFoundable){
- if ((pt->IsActive() || (pt->fRemoval==10) )){
+ if ((pt->IsActive() || (pt->GetRemoval()==10) )){
found++;
if (fDebug>0){
cerr<<found<<'\r';
}
- pt->fLab2 = i;
+ pt->SetLab2(i);
}
else
delete fSeeds->RemoveAt(i);
{
//
//
+ if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial();
TStopwatch timer;
timer.Start();
Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();
}
+TObjArray * AliTPCtrackerMI::TrackingSpecial()
+{
+ //
+ // seeding adjusted for laser and cosmic tests - short tracks with big inclination angle
+ // no primary vertex seeding tried
+ //
+ TStopwatch timer;
+ timer.Start();
+ Int_t nup=fOuterSec->GetNRows()+fInnerSec->GetNRows();
+
+ TObjArray * seeds = new TObjArray;
+ TObjArray * arr=0;
+
+ Int_t gap = 15;
+ Float_t cuts[4];
+ Float_t fnumber = 3.0;
+ Float_t fdensity = 3.0;
+
+ // find secondaries
+ cuts[0] = AliTPCReconstructor::GetRecoParam()->GetMaxC(); // max curvature
+ cuts[1] = 3.5; // max tan(phi) angle for seeding
+ cuts[2] = 3.; // not used (cut on z primary vertex)
+ cuts[3] = 3.5; // max tan(theta) angle for seeding
+
+ for (Int_t delta = 0; nup-delta-gap-1>0; delta+=3){
+ //
+ arr = Tracking(4,nup-1-delta,nup-1-delta-gap,cuts,-1);
+ SumTracks(seeds,arr);
+ SignClusters(seeds,fnumber,fdensity);
+ }
+
+ if (fDebug>0){
+ Info("Tracking()","\n\nSecondary seeding\t%d\n\n",seeds->GetEntriesFast());
+ timer.Print();
+ timer.Start();
+ }
+
+ return seeds;
+ //
+
+}
+
+
void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const
{
//
for (Int_t i=0;i<nseed;i++){
AliTPCseed *pt=(AliTPCseed*)arr2->UncheckedAt(i);
if (pt){
-
+ //
+ // remove tracks with too big curvature
+ //
+ if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){
+ delete arr2->RemoveAt(i);
+ continue;
+ }
+ // REMOVE VERY SHORT TRACKS
+ if (pt->GetNumberOfClusters()<20){
+ delete arr2->RemoveAt(i);
+ continue;
+ }// patch 28 fev06
// NORMAL ACTIVE TRACK
if (pt->IsActive()){
arr1->AddLast(arr2->RemoveAt(i));
continue;
}
//remove not usable tracks
- if (pt->fRemoval!=10){
- delete arr2->RemoveAt(i);
- continue;
- }
- // REMOVE VERY SHORT TRACKS
- if (pt->GetNumberOfClusters()<20){
+ if (pt->GetRemoval()!=10){
delete arr2->RemoveAt(i);
continue;
}
+
// ENABLE ONLY ENOUGH GOOD STOPPED TRACKS
if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
arr1->AddLast(arr2->RemoveAt(i));
if (!pt) continue;
if (!t.IsActive()) continue;
// follow prolongation to the first layer
- if ( (fSectors ==fInnerSec) || (t.fFirstPoint-fParam->GetNRowLow()>rfirst+1) )
+ if ( (fSectors ==fInnerSec) || (t.GetFirstPoint()-fParam->GetNRowLow()>rfirst+1) )
FollowProlongation(t, rfirst+1);
}
if (nr==80) pt->UpdateReference();
if (!pt->IsActive()) continue;
// if ( (fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())<nr) continue;
- if (pt->fRelativeSector>17) {
+ if (pt->GetRelativeSector()>17) {
continue;
}
UpdateClusters(t,nr);
if (!pt) continue;
if (!pt->IsActive()) continue;
// if ((fSectors ==fOuterSec) && (pt->fFirstPoint-fParam->GetNRowLow())<nr) continue;
- if (pt->fRelativeSector>17) {
+ if (pt->GetRelativeSector()>17) {
continue;
}
FollowToNextCluster(*pt,nr);
pt->Modify(fac);
//
//rotate to current local system at first accepted point
- Int_t index = pt->GetClusterIndex2(pt->fFirstPoint);
+ Int_t index = pt->GetClusterIndex2(pt->GetFirstPoint());
Int_t sec = (index&0xff000000)>>24;
sec = sec%18;
Float_t angle1 = fInnerSec->GetAlpha()*sec+fInnerSec->GetAlphaShift();
AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
if (pt) {
pt->Modify(fac);
- pt->fFirstPoint = pt->fLastPoint;
+ pt->SetFirstPoint(pt->GetLastPoint());
}
}
}
if (pt&& pt->GetKinkIndex(0)>0) {
AliESDkink * kink = fEvent->GetKink(pt->GetKinkIndex(0)-1);
- pt->fFirstPoint = kink->GetTPCRow0();
+ pt->SetFirstPoint(kink->GetTPCRow0());
fSectors = fInnerSec;
FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1);
}
Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
- t.fRelativeSector = Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
+ t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
}
}
// Float_t padlength = fParam->GetPadPitchLength(seed->fSector);
Float_t padlength = GetPadPitchLength(row);
//
- Float_t sresy = (seed->fSector < fParam->GetNSector()/2) ? 0.2 :0.3;
- Float_t angulary = seed->GetSnp();
+ Float_t sresy = (seed->GetSector() < fParam->GetNSector()/2) ? 0.2 :0.3;
+ Double_t angulary = seed->GetSnp();
angulary = angulary*angulary/(1-angulary*angulary);
- seed->fCurrentSigmaY2 = sd2+padlength*padlength*angulary/12.+sresy*sresy;
+ seed->SetCurrentSigmaY2(sd2+padlength*padlength*angulary/12.+sresy*sresy);
//
Float_t sresz = fParam->GetZSigma();
Float_t angularz = seed->GetTgl();
- seed->fCurrentSigmaZ2 = sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz;
+ seed->SetCurrentSigmaZ2(sd2+padlength*padlength*angularz*angularz*(1+angulary)/12.+sresz*sresz);
/*
Float_t wy = GetSigmaY(seed);
Float_t wz = GetSigmaZ(seed);
//
//
Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
- Float_t padlength = fParam->GetPadPitchLength(seed->fSector);
- Float_t sres = (seed->fSector < fParam->GetNSector()/2) ? 0.2 :0.3;
+ Float_t padlength = fParam->GetPadPitchLength(seed->GetSector());
+ Float_t sres = (seed->GetSector() < fParam->GetNSector()/2) ? 0.2 :0.3;
Float_t angular = seed->GetSnp();
angular = angular*angular/(1-angular*angular);
// angular*=angular;
//
//
Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
- Float_t padlength = fParam->GetPadPitchLength(seed->fSector);
+ Float_t padlength = fParam->GetPadPitchLength(seed->GetSector());
Float_t sres = fParam->GetZSigma();
Float_t angular = seed->GetTgl();
Float_t res = TMath::Sqrt(sd2+padlength*padlength*angular*angular/12.+sres*sres);
//__________________________________________________________________________
-void AliTPCtrackerMI::CookLabel(AliTPCseed *t, Float_t wrong) const {
+void AliTPCtrackerMI::CookLabel(AliKalmanTrack *tk, Float_t wrong) const {
//--------------------------------------------------------------------
//This function "cooks" a track label. If label<0, this track is fake.
//--------------------------------------------------------------------
+ AliTPCseed * t = (AliTPCseed*)tk;
Int_t noc=t->GetNumberOfClusters();
if (noc<10){
//printf("\nnot founded prolongation\n\n\n");
if (index&0x8000) continue;
//
//clusters[current]=GetClusterMI(index);
- if (t->fClusterPointer[i]){
- clusters[current]=t->fClusterPointer[i];
+ if (t->GetClusterPointer(i)){
+ clusters[current]=t->GetClusterPointer(i);
current++;
}
}
if (index&0x8000) continue;
//
//clusters[current]=GetClusterMI(index);
- if (t->fClusterPointer[i]){
- clusters[current]=t->fClusterPointer[i];
+ if (t->GetClusterPointer(i)){
+ clusters[current]=t->GetClusterPointer(i);
current++;
}
}
fRow=new AliTPCRow[fN];
for (Int_t i=0; i<fN; i++) {
fRow[i].SetX(par->GetPadRowRadiiLow(i));
- fRow[i].fDeadZone =1.5; //1.5 cm of dead zone
+ fRow[i].SetDeadZone(1.5); //1.5 cm of dead zone
}
} else {
fAlpha=par->GetOuterAngle();
fRow=new AliTPCRow[fN];
for (Int_t i=0; i<fN; i++) {
fRow[i].SetX(par->GetPadRowRadiiUp(i));
- fRow[i].fDeadZone =1.5; // 1.5 cm of dead zone
+ fRow[i].SetDeadZone(1.5); // 1.5 cm of dead zone
}
}
}
-AliTPCtrackerMI::AliTPCRow::AliTPCRow() {
+AliTPCtrackerMI::AliTPCRow::AliTPCRow():
+ fDeadZone(0.),
+ fClusters1(0),
+ fN1(0),
+ fClusters2(0),
+ fN2(0),
+ fN(0),
+ fX(0.)
+{
//
// default constructor
- fN=0;
- fN1=0;
- fN2=0;
- fClusters1=0;
- fClusters2=0;
+ //
}
AliTPCtrackerMI::AliTPCRow::~AliTPCRow(){
// Return the index of the nearest cluster in z y
//-----------------------------------------------------------------------
Float_t maxdistance = roady*roady + roadz*roadz;
- Int_t iz1 = TMath::Max(fFastCluster[Int_t(z-roadz+254.5)]-1,0);
- Int_t iz2 = TMath::Min(fFastCluster[Int_t(z+roadz+255.5)]+1,fN);
-
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);
+
//FindNearest3(y,z,roady,roadz,index);
// for (Int_t i=Find(z-roadz); i<fN; i++) {
for (Int_t i=iz1; i<iz2; i++) {
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff