// The systematic errors due to the misalignment and miscalibration are added to the covariance matrix
// of the tracks (not to the clusters as they are dependent):
// The parameters form AliTPCRecoParam are used AliTPCRecoParam::GetSystematicError
-// The systematic errors are expressed there in RMS - position (cm), angle (rad), curvature (1/cm)
+// The systematic errors are expressed there in RMS - position (cm), angle (rad), curvature (1/GeV)
// The default values are 0.
//
// The sytematic errors are added to the covariance matrix in following places:
#include "AliTPCTransform.h"
#include "AliTPCClusterParam.h"
#include "AliTPCdEdxInfo.h"
-#include "AliClonesPool.h"
-#include "AliPoolsSet.h"
+#include "AliDCSSensorArray.h"
+#include "AliDCSSensor.h"
+#include "AliDAQ.h"
+#include "AliCosmicTracker.h"
//
fDebugStreamer(0),
fUseHLTClusters(4),
fSeedsPool(0),
- fKinksPool(0)
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//
// default constructor
fDebugStreamer(0),
fUseHLTClusters(4),
fSeedsPool(0),
- fKinksPool(0)
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//---------------------------------------------------------------------
// The main TPC tracker constructor
fDebugStreamer = new TTreeSRedirector("TPCdebug.root");
}
//
- fSeedsPool = new AliClonesPool("AliTPCseed",1000);
- fSeedsPool->SetName("TPCSeed");
- fKinksPool = new AliClonesPool("AliKink",1000);
- fKinksPool->SetName("TPCKink");
-
+ fSeedsPool = new TClonesArray("AliTPCseed",1000);
}
//________________________________________________________________________
AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
fDebugStreamer(0),
fUseHLTClusters(4),
fSeedsPool(0),
- fKinksPool(0)
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//------------------------------------
// dummy copy constructor
delete fSeeds;
}
if (fDebugStreamer) delete fDebugStreamer;
- if (fSeedsPool && !fPools) delete fSeedsPool; // RS: owned by reconstruction pools (if exist)
- if (fKinksPool && !fPools) delete fKinksPool; // RS: owned by reconstruction pools (if exist)
+ if (fSeedsPool) delete fSeedsPool;
}
if(row == 27 || row == 76) continue;
}
- Int_t left=0;
+ // Int_t left=0;
if (sec<fkNIS*2){
- left = sec/fkNIS;
+ // left = sec/fkNIS;
fInnerSec[sec%fkNIS].InsertCluster(clust, count[sec][row], fkParam);
}
else{
- left = (sec-fkNIS*2)/fkNOS;
+ // left = (sec-fkNIS*2)/fkNOS;
fOuterSec[(sec-fkNIS*2)%fkNOS].InsertCluster(clust, count[sec][row], fkParam);
}
}
if (TMath::Abs(angle-t.GetAlpha())>0.001){
Double_t rotation = angle-t.GetAlpha();
t.SetRelativeSector(relativesector);
- if (!t.Rotate(rotation)) return 0;
+ if (!t.Rotate(rotation)) {
+ t.SetClusterIndex(nr, t.GetClusterIndex(nr) | 0x8000);
+ return 0;
+ }
+ }
+ if (!t.PropagateTo(x)) {
+ t.SetClusterIndex(nr, t.GetClusterIndex(nr) | 0x8000);
+ return 0;
}
- if (!t.PropagateTo(x)) return 0;
//
t.SetCurrentCluster(cl);
t.SetRow(nr);
if (!pt) continue;
//
if (quality[trackindex]<0){
- fSeedsPool->MarkSlotFree( arr->RemoveAt(trackindex) );
+ MarkSeedFree( arr->RemoveAt(trackindex) );
continue;
}
//
"pt.="<<pt<<
"\n";
}
- fSeedsPool->MarkSlotFree( arr->RemoveAt(trackindex) );
+ MarkSeedFree( arr->RemoveAt(trackindex) );
continue;
}
if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){ //remove short tracks
"pt.="<<pt<<
"\n";
}
- fSeedsPool->MarkSlotFree( arr->RemoveAt(trackindex) );
+ MarkSeedFree( arr->RemoveAt(trackindex) );
continue;
}
}
pt->GetClusterStatistic(0,160,found, foundable,shared);
if (shared/float(found)>0.3) {
if (shared/float(found)>0.9 ){
- //fSeedsPool->MarkSlotFree( arr->RemoveAt(i) );
+ //MarkSeedFree( arr->RemoveAt(i) );
}
continue;
}
}
signal[3] = seed->GetDEDXregion(4);
//
- AliClonesPool* pooldEdx = fPools ? fPools->GetPoolTPCdEdx() : 0;
- AliTPCdEdxInfo * infoTpcPid = 0;
- if (pooldEdx) {
- infoTpcPid = new(pooldEdx->NextFreeSlot()) AliTPCdEdxInfo();
- pooldEdx->RegisterClone(pooldEdx);
- }
- else infoTpcPid = new AliTPCdEdxInfo();
+ AliTPCdEdxInfo * infoTpcPid = new AliTPCdEdxInfo();
infoTpcPid->SetTPCSignalRegionInfo(signal, ncl, nrows);
esd->SetTPCdEdxInfo(infoTpcPid);
//
// add seed to the esd track in Calib level
//
Bool_t storeFriend = gRandom->Rndm()<(kMaxFriendTracks)/Float_t(nseed);
- if (AliTPCReconstructor::StreamLevel()>0 &&storeFriend){
- AliTPCseed * seedCopy = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(*seed, kTRUE);
- fSeedsPool->RegisterClone(seedCopy);
+ if (AliTPCReconstructor::StreamLevel()>0 &&storeFriend){
+ // RS: this is the only place where the seed is created not in the pool,
+ // since it should belong to ESDevent
+ AliTPCseed * seedCopy = new AliTPCseed(*seed, kTRUE);
esd->AddCalibObject(seedCopy);
}
ntracks++;
//FindKinks(fSeeds,event);
if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(2,fSeeds);
Info("RefitInward","Number of refitted tracks %d",ntracks);
+
+ AliCosmicTracker::FindCosmic(event, kTRUE);
+
return 0;
}
}
-void AliTPCtrackerMI::DeleteSeeds()
+Int_t AliTPCtrackerMI::PostProcess(AliESDEvent *event)
+{
+ //
+ // Post process events
+ //
+ if (!event) return 0;
+
+ //
+ // Set TPC event status
+ //
+
+ // event affected by HV dip
+ // reset TPC status
+ if(IsTPCHVDipEvent(event)) {
+ event->ResetDetectorStatus(AliDAQ::kTPC);
+ }
+
+ //printf("Status %d \n", event->IsDetectorOn(AliDAQ::kTPC));
+
+ return 0;
+}
+
+
+ void AliTPCtrackerMI::DeleteSeeds()
{
//
fSeeds->Clear();
- fSeedsPool->Clear("C"); // nominally allocate memory
+ ResetSeedsPool();
delete fSeeds;
fSeeds =0;
}
AliTPCtrack t(*esd);
t.SetNumberOfClusters(0);
// AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha());
- AliTPCseed *seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(t/*,t.GetAlpha()*/);
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed *seed = new( NextFreeSeed() ) AliTPCseed(t/*,t.GetAlpha()*/);
+ seed->SetPoolID(fLastSeedID);
seed->SetUniqueID(esd->GetID());
AddCovariance(seed); //add systematic ucertainty
for (Int_t ikink=0;ikink<3;ikink++) {
if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) == 0 ) seed->ResetCovariance(10.);
//if ( direction ==2 && ((status & AliESDtrack::kTPCout) == 0) ) {
// fSeeds->AddAt(0,i);
- // fSeedsPool->MarkSlotFree( seed );
+ // MarkSeedFree( seed );
// continue;
//}
if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) > 0 ) {
if (TMath::Abs(alpha) > 0.001) { // This should not happen normally
AliWarning(Form("Rotating track over %f",alpha));
if (!seed->Rotate(alpha)) {
- fSeedsPool->MarkSlotFree( seed );
+ MarkSeedFree( seed );
continue;
}
}
Double_t x[5], c[15];
// Int_t di = i1-i2;
//
- AliTPCseed * seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed();
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed();
+ seed->SetPoolID(fLastSeedID);
Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
Double_t cs=cos(alpha), sn=sin(alpha);
//
}
- Double_t dym = 0;
- Double_t dzm = 0;
- if (cm){
- dym = ym - cm->GetY();
- dzm = zm - cm->GetZ();
- }
+ // Double_t dym = 0;
+ // Double_t dzm = 0;
+ // if (cm){
+ // dym = ym - cm->GetY();
+ // dzm = zm - cm->GetZ();
+ // }
nin2++;
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
UInt_t index=kr1.GetIndex(is);
- if (seed) {fSeedsPool->MarkSlotFree(seed); seed = 0;}
- AliTPCseed *track = seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(x1, ns*alpha+shift, x, c, index);
- fSeedsPool->RegisterClone(seed);
+ if (seed) {MarkSeedFree(seed); seed = 0;}
+ AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1, ns*alpha+shift, x, c, index);
+ seed->SetPoolID(fLastSeedID);
track->SetIsSeeding(kTRUE);
track->SetSeed1(i1);
track->SetSeed2(i2);
Int_t foundable,found,shared;
track->GetClusterStatistic((i1+i2)/2,i1, found, foundable, shared, kTRUE);
if ((found<0.55*foundable) || shared>0.5*found || (track->GetSigmaY2()+track->GetSigmaZ2())>0.5){
- fSeedsPool->MarkSlotFree(seed); seed = 0;
+ MarkSeedFree(seed); seed = 0;
continue;
}
//}
if (track->GetNumberOfClusters()<(i1-i2)*0.5 ||
track->GetNumberOfClusters() < track->GetNFoundable()*0.6 ||
track->GetNShared()>0.4*track->GetNumberOfClusters() ) {
- fSeedsPool->MarkSlotFree(seed); seed = 0;
+ MarkSeedFree(seed); seed = 0;
continue;
}
nout1++;
track2->SetBConstrain(kFALSE);
track2->SetSeedType(1);
arr->AddLast(track2);
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
continue;
}
else{
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
continue;
}
track->SetSeedType(0);
arr->AddLast(track); // note, track is seed, don't free the seed
- seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed;
- fSeedsPool->RegisterClone(seed);
+ seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
nout2++;
// don't consider other combinations
if (track->GetNumberOfClusters() > track->GetNFoundable()*0.8)
if (fDebug>3){
Info("MakeSeeds3","\nSeeding statistic:\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2);
}
- if (seed) fSeedsPool->MarkSlotFree( seed );
+ if (seed) MarkSeedFree( seed );
}
Double_t x[5], c[15];
//
// make temporary seed
- AliTPCseed * seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed;
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
Double_t alpha=fOuterSec->GetAlpha(), shift=fOuterSec->GetAlphaShift();
// Double_t cs=cos(alpha), sn=sin(alpha);
//
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
index=kr1.GetIndex(is);
- if (seed) {fSeedsPool->MarkSlotFree( seed ); seed = 0;}
- AliTPCseed *track = seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(x1, sec*alpha+shift, x, c, index);
- fSeedsPool->RegisterClone(seed);
+ if (seed) {MarkSeedFree( seed ); seed = 0;}
+ AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1, sec*alpha+shift, x, c, index);
+ seed->SetPoolID(fLastSeedID);
track->SetIsSeeding(kTRUE);
FollowProlongation(*track, i1-7,1);
if (track->GetNumberOfClusters() < track->GetNFoundable()*0.75 ||
track->GetNShared()>0.6*track->GetNumberOfClusters() || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.6){
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
continue;
}
nout1++;
if (track->GetNumberOfClusters()<(i1-i2)*0.5 ||
track->GetNumberOfClusters()<track->GetNFoundable()*0.7 ||
track->GetNShared()>2. || track->GetChi2()/track->GetNumberOfClusters()>6 || ( track->GetSigmaY2()+ track->GetSigmaZ2())>0.5 ) {
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
continue;
}
track2->SetBConstrain(kFALSE);
track2->SetSeedType(4);
arr->AddLast(track2);
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
}
if (fDebug>3){
Info("MakeSeeds5","\nSeeding statiistic:\t%d\t%d\t%d\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin,nout1,nout2,nout3);
}
- if (seed) fSeedsPool->MarkSlotFree(seed);
+ if (seed) MarkSeedFree(seed);
}
AliTPCpolyTrack polytrack;
Int_t nclusters=fSectors[sec][row0];
- AliTPCseed * seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed;
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
Int_t sumused=0;
Int_t cused=0;
UInt_t index=0;
//kr0.GetIndex(is);
- if (seed) {fSeedsPool->MarkSlotFree( seed ); seed = 0;}
- AliTPCseed *track = seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(x1,sec*alpha+shift,x,c,index);
- fSeedsPool->RegisterClone(seed);
+ if (seed) {MarkSeedFree( seed ); seed = 0;}
+ AliTPCseed *track = seed = new( NextFreeSeed() ) AliTPCseed(x1,sec*alpha+shift,x,c,index);
+ seed->SetPoolID(fLastSeedID);
track->SetIsSeeding(kTRUE);
Int_t rc=FollowProlongation(*track, i2);
if (constrain) track->SetBConstrain(1);
if (rc==0 || track->GetNumberOfClusters()<(i1-i2)*0.5 ||
track->GetNumberOfClusters() < track->GetNFoundable()*0.6 ||
track->GetNShared()>0.4*track->GetNumberOfClusters()) {
- fSeedsPool->MarkSlotFree( seed ); seed = 0;
+ MarkSeedFree( seed ); seed = 0;
}
else {
arr->AddLast(track); // track IS seed, don't free seed
- seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed;
- fSeedsPool->RegisterClone(seed);
+ seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
}
nin3++;
}
if (fDebug>3){
Info("MakeSeeds2","\nSeeding statiistic:\t%d\t%d\t%d\t%d",nin0,nin1,nin2,nin3);
}
- if (seed) fSeedsPool->MarkSlotFree( seed );
+ if (seed) MarkSeedFree( seed );
}
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(x2[0]);
- AliTPCseed *seed = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed *seed = new( NextFreeSeed() ) AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ seed->SetPoolID(fLastSeedID);
// Double_t y0,z0,y1,z1, y2,z2;
//seed->GetProlongation(x0[0],y0,z0);
// seed->GetProlongation(x1[0],y1,z1);
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
- AliTPCseed *seed=new( fSeedsPool->NextFreeSlot() ) AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed *seed=new( NextFreeSeed() ) AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ seed->SetPoolID(fLastSeedID);
seed->SetLastPoint(row[2]);
seed->SetFirstPoint(row[2]);
return seed;
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(xyz[2][0]);
- AliTPCseed *seed=new( fSeedsPool->NextFreeSlot() ) AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
- fSeedsPool->RegisterClone(seed);
+ AliTPCseed *seed=new( NextFreeSeed() ) AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ seed->SetPoolID(fLastSeedID);
seed->SetLastPoint(row[2]);
seed->SetFirstPoint(row[2]);
for (Int_t i=row[0];i<row[2];i++){
//
//
//
- fSeedsPool->MarkSlotFree( array->RemoveAt(index1) );
+ MarkSeedFree( array->RemoveAt(index1) );
}
}
}
//
// RS something is wrong in this routine: not all seeds are assigned to daughters and mothers array, but they all are queried
// to check later
- if (fPools && !fPools->GetPool(AliPoolsSet::kPoolTPCKink)) fPools->SetPool(fKinksPool,AliPoolsSet::kPoolTPCKink);
- fKinksPool->Clear();
+
+ TObjArray *kinks= new TObjArray(10000);
// TObjArray *v0s= new TObjArray(10000);
Int_t nentries = array->GetEntriesFast();
- AliHelix *helixes = new AliHelix[nentries];
- Int_t sign[nentries];
- Int_t nclusters[nentries];
- Float_t alpha[nentries];
- Int_t usage[nentries];
- Float_t zm[nentries];
- Float_t z0[nentries];
- Float_t fim[nentries];
- Float_t shared[nentries];
- Bool_t circular[nentries];
- Float_t dca[nentries];
+ AliHelix *helixes = new AliHelix[nentries];
+ Int_t *sign = new Int_t[nentries];
+ Int_t *nclusters = new Int_t[nentries];
+ Float_t *alpha = new Float_t[nentries];
+ 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];
+ Float_t *fim = new Float_t[nentries];
+ Float_t *shared = new Float_t[nentries];
+ Bool_t *circular = new Bool_t[nentries];
+ Float_t *dca = new Float_t[nentries];
//const AliESDVertex * primvertex = esd->GetVertex();
//
// nentries = array->GetEntriesFast();
+ //
+
//
//
for (Int_t i=0;i<nentries;i++){
}
}
//
- // Find kinks loop
+ // Finf kinks loop
//
- AliKink* kink = new( fKinksPool->NextFreeSlot() ) AliKink(); fKinksPool->RegisterClone(kink);
//
for (Int_t i =0;i<nentries;i++){
if (sign[i]==0) continue;
continue;
}
//
- kink = new( fKinksPool->NextFreeSlot() ) AliKink(); fKinksPool->RegisterClone(kink);
+ kinks->AddLast(kink);
+ kink = new AliKink;
ncandidates++;
}
}
- // eliminate last dummy kink
- fKinksPool->MarkSlotFree(kink);
- kink = 0;
- if (ncandidates!=fKinksPool->GetEntriesFast() ) {
- AliError(Form("Mismatch in number of kinks: %d %d",ncandidates,fKinksPool->GetEntriesFast()));
- }
+ //
// sort the kinks according quality - and refit them towards vertex
//
- Int_t nkinks = fKinksPool->GetEntriesFast();
- Float_t quality[nkinks];
- Int_t indexes[nkinks];
- AliTPCseed* mothers[nkinks];;
- AliTPCseed* daughters[nkinks];
+ Int_t nkinks = kinks->GetEntriesFast();
+ Float_t *quality = new Float_t[nkinks];
+ Int_t *indexes = new Int_t[nkinks];
+ AliTPCseed *mothers = new AliTPCseed[nkinks];
+ AliTPCseed *daughters = new AliTPCseed[nkinks];
//
//
for (Int_t i=0;i<nkinks;i++){
quality[i] =100000;
- mothers[i] = daughters[i] = 0;
- AliKink *kinkl = (AliKink*)fKinksPool->At(i);
+ AliKink *kinkl = (AliKink*)kinks->At(i);
//
// refit kinks towards vertex
//
if (first>ktrack1->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30);
AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE);
//
- if (seed0 && seed1) {
+ if (seed0 && seed1){
kinkl->SetStatus(1,8);
if (RefitKink(*seed0,*seed1,*kinkl)) kinkl->SetStatus(1,9);
row0 = GetRowNumber(kinkl->GetR());
sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
- mothers[i] = seed0;
- daughters[i] = seed1;
+ mothers[i] = *seed0;
+ daughters[i] = *seed1;
}
- else {
- fKinksPool->MarkSlotFree(kinkl);
- if (seed0) fSeedsPool->MarkSlotFree( seed0 );
- if (seed1) fSeedsPool->MarkSlotFree( seed1 );
+ else{
+ delete kinks->RemoveAt(i);
+ if (seed0) MarkSeedFree( seed0 );
+ if (seed1) MarkSeedFree( seed1 );
continue;
}
if (kinkl->GetDistance()>0.5 || kinkl->GetR()<110 || kinkl->GetR()>240) {
- fKinksPool->MarkSlotFree(kinkl);
- if (seed0) fSeedsPool->MarkSlotFree( seed0 );
- if (seed1) fSeedsPool->MarkSlotFree( seed1 );
- mothers[i] = daughters[i] = 0;
+ delete kinks->RemoveAt(i);
+ if (seed0) MarkSeedFree( seed0 );
+ if (seed1) MarkSeedFree( seed1 );
continue;
}
+ //
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
}
//
if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.); //the longest -clossest will win
//remove double find kinks
//
for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
- AliKink * kink0 = (AliKink*) fKinksPool->At(indexes[ikink0]);
+ AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
if (!kink0) continue;
- AliTPCseed *mother0 = mothers[indexes[ikink0]];
- AliTPCseed *daughter0 = daughters[indexes[ikink0]];
- if (!mother0 || !daughter0) continue;
//
for (Int_t ikink1=0;ikink1<ikink0;ikink1++){
- AliKink * kink1 = (AliKink*) fKinksPool->At(indexes[ikink1]);
+ kink0 = (AliKink*) kinks->At(indexes[ikink0]);
+ if (!kink0) continue;
+ AliKink * kink1 = (AliKink*) kinks->At(indexes[ikink1]);
if (!kink1) continue;
- AliTPCseed *mother1 = mothers[indexes[ikink1]];
- AliTPCseed *daughter1 = daughters[indexes[ikink1]];
- if (!mother1 || !daughter1) continue;
// if not close kink continue
if (TMath::Abs(kink1->GetPosition()[2]-kink0->GetPosition()[2])>10) continue;
if (TMath::Abs(kink1->GetPosition()[1]-kink0->GetPosition()[1])>10) continue;
if (TMath::Abs(kink1->GetPosition()[0]-kink0->GetPosition()[0])>10) continue;
//
+ AliTPCseed &mother0 = mothers[indexes[ikink0]];
+ AliTPCseed &daughter0 = daughters[indexes[ikink0]];
+ AliTPCseed &mother1 = mothers[indexes[ikink1]];
+ AliTPCseed &daughter1 = daughters[indexes[ikink1]];
Int_t row0 = (kink0->GetTPCRow0()+kink1->GetTPCRow0())/2;
//
Int_t same = 0;
Int_t bothd = 0;
//
for (Int_t i=0;i<row0;i++){
- if (mother0->GetClusterIndex(i)>0 && mother1->GetClusterIndex(i)>0){
+ if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){
both++;
bothm++;
- if (mother0->GetClusterIndex(i)==mother1->GetClusterIndex(i)){
+ if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
same++;
samem++;
}
for (Int_t i=row0;i<158;i++){
//if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){ // RS: Bug?
- if (daughter0->GetClusterIndex(i)>0 && daughter1->GetClusterIndex(i)>0){
+ if (daughter0.GetClusterIndex(i)>0 && daughter1.GetClusterIndex(i)>0){
both++;
bothd++;
- if (daughter0->GetClusterIndex(i)==daughter1->GetClusterIndex(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->GetNumberOfClusters()+daughter0->GetNumberOfClusters();
- Int_t sum1 = mother1->GetNumberOfClusters()+daughter1->GetNumberOfClusters();
+ 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;
- fKinksPool->MarkSlotFree(kink0);
- kink0 = 0;
+ delete kinks->RemoveAt(indexes[ikink0]);
break;
}
else{
shared[kink1->GetIndex(0)]= kTRUE;
shared[kink1->GetIndex(1)]= kTRUE;
- fKinksPool->MarkSlotFree(kink1);
- fKinksPool->MarkSlotFree(kink1);
- kink1 = 0;
+ delete kinks->RemoveAt(indexes[ikink1]);
}
}
}
for (Int_t i=0;i<nkinks;i++){
- AliKink * kinkl = (AliKink*) fKinksPool->At(indexes[i]);
+ AliKink * kinkl = (AliKink*) kinks->At(indexes[i]);
if (!kinkl) continue;
kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
Int_t index0 = kinkl->GetIndex(0);
//
//
if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink
- if (mothers[indexes[i]] && daughters[indexes[i]]) {
- if (mothers[indexes[i]]->GetNumberOfClusters()>20 && daughters[indexes[i]]->GetNumberOfClusters()>20 &&
- (mothers[indexes[i]]->GetNumberOfClusters()+daughters[indexes[i]]->GetNumberOfClusters())>100) {
- *ktrack0 = *mothers[indexes[i]];
- *ktrack1 = *daughters[indexes[i]];
- }
+ if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){
+ *ktrack0 = mothers[indexes[i]];
+ *ktrack1 = daughters[indexes[i]];
}
}
//
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
if (track0->GetKinkIndex(0)!=0) continue;
- if (shared[i]) fSeedsPool->MarkSlotFree( array->RemoveAt(i) );
+ if (shared[i]) MarkSeedFree( array->RemoveAt(i) );
}
+
//
//
RemoveUsed2(array,0.5,0.4,30);
}
}
if (Float_t(ishared+1)/Float_t(all+1)>0.5) {
- fSeedsPool->MarkSlotFree( array->RemoveAt(i) );
+ MarkSeedFree( array->RemoveAt(i) );
continue;
}
//
if (track0->GetKinkIndex(0)!=0) continue;
if (track0->GetNumberOfClusters()<80) continue;
- AliTPCseed *pmother = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(); fSeedsPool->RegisterClone(pmother);
- AliTPCseed *pdaughter = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(); fSeedsPool->RegisterClone(pdaughter);
- AliKink *pkink = new( fKinksPool->NextFreeSlot() ) AliKink(); fKinksPool->RegisterClone(pkink);
- //
+ AliTPCseed *pmother = new AliTPCseed();
+ AliTPCseed *pdaughter = new AliTPCseed();
+ AliKink *pkink = new AliKink;
+
AliTPCseed & mother = *pmother;
AliTPCseed & daughter = *pdaughter;
AliKink & kinkl = *pkink;
if (CheckKinkPoint(track0,mother,daughter, kinkl)){
if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) {
- fSeedsPool->MarkSlotFree(pmother);
- fSeedsPool->MarkSlotFree(pdaughter);
- fKinksPool->MarkSlotFree(pkink);
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
continue; //too short tracks
}
if (mother.Pt()<1.4) {
- fSeedsPool->MarkSlotFree(pmother);
- fSeedsPool->MarkSlotFree(pdaughter);
- fKinksPool->MarkSlotFree(pkink);
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
continue;
}
Int_t row0= kinkl.GetTPCRow0();
if (kinkl.GetDistance()>0.5 || kinkl.GetR()<110. || kinkl.GetR()>240.) {
- fSeedsPool->MarkSlotFree(pmother);
- fSeedsPool->MarkSlotFree(pdaughter);
- fKinksPool->MarkSlotFree(pkink);
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
continue;
}
//
mother.SetKinkIndex(0,-(index+1));
daughter.SetKinkIndex(0,index+1);
if (mother.GetNumberOfClusters()>50) {
- fSeedsPool->MarkSlotFree( array->RemoveAt(i) );
- AliTPCseed* mtc = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(mother);
- fSeedsPool->RegisterClone(mtc);
+ MarkSeedFree( array->RemoveAt(i) );
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
array->AddAt(mtc,i);
}
else{
- AliTPCseed* mtc = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(mother);
- fSeedsPool->RegisterClone(mtc);
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
array->AddLast(mtc);
}
- AliTPCseed* dtc = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(daughter);
- fSeedsPool->RegisterClone(dtc);
+ AliTPCseed* dtc = new( NextFreeSeed() ) AliTPCseed(daughter);
+ dtc->SetPoolID(fLastSeedID);
array->AddLast(dtc);
for (Int_t icl=0;icl<row0;icl++) {
if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20);
}
//
}
- fSeedsPool->MarkSlotFree(pmother);
- fSeedsPool->MarkSlotFree(pdaughter);
- fKinksPool->MarkSlotFree(pkink);
+ delete pmother;
+ delete pdaughter;
+ delete pkink;
}
+
+ delete [] daughters;
+ delete [] mothers;
//
- for (int i=nkinks;i--;) {
- if (daughters[i]) fSeedsPool->MarkSlotFree(daughters[i]);
- if (mothers[i]) fSeedsPool->MarkSlotFree(mothers[i]);
- }
- fKinksPool->Clear();
//
+ delete [] dca;
+ delete []circular;
+ delete []shared;
+ delete []quality;
+ delete []indexes;
+ //
+ delete kink;
+ delete[]fim;
+ delete[] zm;
+ delete[] z0;
+ delete [] usage;
+ delete[] alpha;
+ delete[] nclusters;
+ delete[] sign;
delete[] helixes;
+ kinks->Delete();
+ delete kinks;
+
AliInfo(Form("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall));
timer.Print();
}
-Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
+/*
+void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
{
//
- // refit kink towards to the vertex
+ // find kinks
//
//
- AliKink &kink=(AliKink &)knk;
- Int_t row0 = GetRowNumber(kink.GetR());
- FollowProlongation(mother,0);
- mother.Reset(kFALSE);
- //
- FollowProlongation(daughter,row0);
- daughter.Reset(kFALSE);
- FollowBackProlongation(daughter,158);
- daughter.Reset(kFALSE);
- Int_t first = TMath::Max(row0-20,30);
- Int_t last = TMath::Min(row0+20,140);
- //
- const Int_t kNdiv =5;
- AliTPCseed param0[kNdiv]; // parameters along the track
- AliTPCseed param1[kNdiv]; // parameters along the track
- AliKink kinks[kNdiv]; // corresponding kink parameters
+ TObjArray *kinks= new TObjArray(10000);
+ // TObjArray *v0s= new TObjArray(10000);
+ Int_t nentries = array->GetEntriesFast();
+ AliHelix *helixes = new AliHelix[nentries];
+ Int_t *sign = new Int_t[nentries];
+ Int_t *nclusters = new Int_t[nentries];
+ Float_t *alpha = new Float_t[nentries];
+ 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];
+ Float_t *fim = new Float_t[nentries];
+ Float_t *shared = new Float_t[nentries];
+ Bool_t *circular = new Bool_t[nentries];
+ Float_t *dca = new Float_t[nentries];
+ //const AliESDVertex * primvertex = esd->GetVertex();
//
- Int_t rows[kNdiv];
- for (Int_t irow=0; irow<kNdiv;irow++){
- rows[irow] = first +((last-first)*irow)/(kNdiv-1);
- }
- // store parameters along the track
+ // nentries = array->GetEntriesFast();
//
- for (Int_t irow=0;irow<kNdiv;irow++){
- FollowBackProlongation(mother, rows[irow]);
- FollowProlongation(daughter,rows[kNdiv-1-irow]);
- param0[irow] = mother;
- param1[kNdiv-1-irow] = daughter;
- }
+
//
- // define kinks
- for (Int_t irow=0; irow<kNdiv-1;irow++){
- if (param0[irow].GetNumberOfClusters()<kNdiv||param1[irow].GetNumberOfClusters()<kNdiv) continue;
- kinks[irow].SetMother(param0[irow]);
- kinks[irow].SetDaughter(param1[irow]);
- kinks[irow].Update();
- }
//
- // choose kink with best "quality"
- Int_t index =-1;
- Double_t mindist = 10000;
- for (Int_t irow=0;irow<kNdiv;irow++){
- 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].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance());
- normdist/= (param0[irow].GetNumberOfClusters()+param1[irow].GetNumberOfClusters()+40.);
- if (normdist < mindist){
- mindist = normdist;
- index = irow;
+ for (Int_t i=0;i<nentries;i++){
+ sign[i]=0;
+ usage[i]=0;
+ AliTPCseed* track = (AliTPCseed*)array->At(i);
+ if (!track) continue;
+ track->SetCircular(0);
+ shared[i] = kFALSE;
+ track->UpdatePoints();
+ if (( track->GetPoints()[2]- track->GetPoints()[0])>5 && track->GetPoints()[3]>0.8){
+ }
+ nclusters[i]=track->GetNumberOfClusters();
+ alpha[i] = track->GetAlpha();
+ new (&helixes[i]) AliHelix(*track);
+ Double_t xyz[3];
+ helixes[i].Evaluate(0,xyz);
+ sign[i] = (track->GetC()>0) ? -1:1;
+ Double_t x,y,z;
+ x=160;
+ if (track->GetProlongation(x,y,z)){
+ zm[i] = z;
+ fim[i] = alpha[i]+TMath::ATan2(y,x);
}
+ else{
+ zm[i] = track->GetZ();
+ fim[i] = alpha[i];
+ }
+ z0[i]=1000;
+ circular[i]= kFALSE;
+ if (track->GetProlongation(0,y,z)) z0[i] = z;
+ dca[i] = track->GetD(0,0);
}
//
- if (index==-1) return 0;
- //
- //
- param0[index].Reset(kTRUE);
- FollowProlongation(param0[index],0);
- //
- mother = param0[index];
- daughter = param1[index]; // daughter in vertex
//
- kink.SetMother(mother);
- kink.SetDaughter(daughter);
- kink.Update();
- kink.SetTPCRow0(GetRowNumber(kink.GetR()));
- kink.SetTPCncls(param0[index].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));
- daughter.SetLabel(kink.GetLabel(1));
-
- return 1;
-}
-
+ TStopwatch timer;
+ timer.Start();
+ Int_t ncandidates =0;
+ Int_t nall =0;
+ Int_t ntracks=0;
+ Double_t phase[2][2]={{0,0},{0,0}},radius[2]={0,0};
-void AliTPCtrackerMI::UpdateKinkQualityM(AliTPCseed * seed){
//
- // update Kink quality information for mother after back propagation
+ // Find circling track
//
- if (seed->GetKinkIndex(0)>=0) return;
- for (Int_t ikink=0;ikink<3;ikink++){
- Int_t index = seed->GetKinkIndex(ikink);
- if (index>=0) break;
- index = TMath::Abs(index)-1;
- AliESDkink * kink = fEvent->GetKink(index);
- kink->SetTPCDensity(-1,0,0);
- kink->SetTPCDensity(1,0,1);
- //
- Int_t row0 = kink->GetTPCRow0() - 2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
- if (row0<15) row0=15;
- //
- Int_t row1 = kink->GetTPCRow0() + 2 + Int_t( 0.5/ (0.05+kink->GetAngle(2)));
- if (row1>145) row1=145;
- //
- Int_t found,foundable,shared;
- seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
- if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,0);
- seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
- if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,1);
- }
-
-}
+ for (Int_t i0=0;i0<nentries;i0++){
+ AliTPCseed * track0 = (AliTPCseed*)array->At(i0);
+ if (!track0) 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->GetNumberOfClusters()<40) continue;
+ if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
+ if (track0->GetBConstrain()&&track1->GetBConstrain()) continue;
+ if (TMath::Abs(1./track1->GetC())>200) continue;
+ if (track1->GetSigned1Pt()*track0->GetSigned1Pt()>0) continue;
+ if (track1->GetTgl()*track0->GetTgl()>0) continue;
+ if (TMath::Max(TMath::Abs(1./track0->GetC()),TMath::Abs(1./track1->GetC()))>190) continue;
+ if (track0->GetBConstrain()&&track1->OneOverPt()<track0->OneOverPt()) continue; //returning - lower momenta
+ if (track1->GetBConstrain()&&track0->OneOverPt()<track1->OneOverPt()) continue; //returning - lower momenta
+ //
+ Float_t mindcar = TMath::Min(TMath::Abs(dca[i0]),TMath::Abs(dca[i1]));
+ if (mindcar<5) continue;
+ Float_t mindcaz = TMath::Min(TMath::Abs(z0[i0]-GetZ()),TMath::Abs(z0[i1]-GetZ()));
+ if (mindcaz<5) continue;
+ if (mindcar+mindcaz<20) continue;
+ //
+ //
+ Float_t xc0 = helixes[i0].GetHelix(6);
+ Float_t yc0 = helixes[i0].GetHelix(7);
+ Float_t r0 = helixes[i0].GetHelix(8);
+ Float_t xc1 = helixes[i1].GetHelix(6);
+ Float_t yc1 = helixes[i1].GetHelix(7);
+ Float_t r1 = helixes[i1].GetHelix(8);
+
+ Float_t rmean = (r0+r1)*0.5;
+ Float_t delta =TMath::Sqrt((xc1-xc0)*(xc1-xc0)+(yc1-yc0)*(yc1-yc0));
+ //if (delta>30) continue;
+ if (delta>rmean*0.25) continue;
+ if (TMath::Abs(r0-r1)/rmean>0.3) continue;
+ //
+ Int_t npoints = helixes[i0].GetRPHIintersections(helixes[i1], phase, radius,10);
+ if (npoints==0) continue;
+ helixes[i0].GetClosestPhases(helixes[i1], phase);
+ //
+ Double_t xyz0[3];
+ Double_t xyz1[3];
+ Double_t hangles[3];
+ helixes[i0].Evaluate(phase[0][0],xyz0);
+ helixes[i1].Evaluate(phase[0][1],xyz1);
-void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){
- //
- // update Kink quality information for daughter after refit
- //
- if (seed->GetKinkIndex(0)<=0) return;
- for (Int_t ikink=0;ikink<3;ikink++){
- Int_t index = seed->GetKinkIndex(ikink);
- if (index<=0) break;
- index = TMath::Abs(index)-1;
- AliESDkink * kink = fEvent->GetKink(index);
- kink->SetTPCDensity(-1,1,0);
- kink->SetTPCDensity(-1,1,1);
- //
- Int_t row0 = kink->GetTPCRow0() -2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
- if (row0<15) row0=15;
- //
- Int_t row1 = kink->GetTPCRow0() +2 + Int_t( 0.5/ (0.05+kink->GetAngle(2)));
- if (row1>145) row1=145;
- //
- Int_t found,foundable,shared;
- seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
- if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,0);
- seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
- if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,1);
- }
+ helixes[i0].GetAngle(phase[0][0],helixes[i1],phase[0][1],hangles);
+ Double_t deltah[2],deltabest;
+ if (hangles[2]<2.8) continue;
+ if (npoints>0){
+ Int_t ibest=0;
+ helixes[i0].ParabolicDCA(helixes[i1],phase[0][0],phase[0][1],radius[0],deltah[0],2);
+ if (npoints==2){
+ helixes[i0].ParabolicDCA(helixes[i1],phase[1][0],phase[1][1],radius[1],deltah[1],2);
+ if (deltah[1]<deltah[0]) ibest=1;
+ }
+ deltabest = TMath::Sqrt(deltah[ibest]);
+ helixes[i0].Evaluate(phase[ibest][0],xyz0);
+ helixes[i1].Evaluate(phase[ibest][1],xyz1);
+ helixes[i0].GetAngle(phase[ibest][0],helixes[i1],phase[ibest][1],hangles);
+ Double_t radiusbest = TMath::Sqrt(radius[ibest]);
+ //
+ if (deltabest>6) continue;
+ if (mindcar+mindcaz<40 && (hangles[2]<3.12||deltabest>3)) continue;
+ Bool_t lsign =kFALSE;
+ if (hangles[2]>3.06) lsign =kTRUE;
+ //
+ if (lsign){
+ circular[i0] = kTRUE;
+ circular[i1] = kTRUE;
+ if (track0->OneOverPt()<track1->OneOverPt()){
+ track0->SetCircular(track0->GetCircular()+1);
+ track1->SetCircular(track1->GetCircular()+2);
+ }
+ else{
+ track1->SetCircular(track1->GetCircular()+1);
+ track0->SetCircular(track0->GetCircular()+2);
+ }
+ }
+ if (lsign&&AliTPCReconstructor::StreamLevel()>1){
+ //debug stream
+ Int_t lab0=track0->GetLabel();
+ Int_t lab1=track1->GetLabel();
+ TTreeSRedirector &cstream = *fDebugStreamer;
+ cstream<<"Curling"<<
+ "lab0="<<lab0<<
+ "lab1="<<lab1<<
+ "Tr0.="<<track0<<
+ "Tr1.="<<track1<<
+ "dca0="<<dca[i0]<<
+ "dca1="<<dca[i1]<<
+ "mindcar="<<mindcar<<
+ "mindcaz="<<mindcaz<<
+ "delta="<<delta<<
+ "rmean="<<rmean<<
+ "npoints="<<npoints<<
+ "hangles0="<<hangles[0]<<
+ "hangles2="<<hangles[2]<<
+ "xyz0="<<xyz0[2]<<
+ "xyzz1="<<xyz1[2]<<
+ "z0="<<z0[i0]<<
+ "z1="<<z0[i1]<<
+ "radius="<<radiusbest<<
+ "deltabest="<<deltabest<<
+ "phase0="<<phase[ibest][0]<<
+ "phase1="<<phase[ibest][1]<<
+ "\n";
+ }
+ }
+ }
+ }
+ //
+ // Finf kinks loop
+ //
+ //
+ for (Int_t i =0;i<nentries;i++){
+ if (sign[i]==0) continue;
+ AliTPCseed * track0 = (AliTPCseed*)array->At(i);
+ if (track0==0) {
+ AliInfo("seed==0");
+ continue;
+ }
+ ntracks++;
+ //
+ Double_t cradius0 = 40*40;
+ Double_t cradius1 = 270*270;
+ Double_t cdist1=8.;
+ Double_t cdist2=8.;
+ Double_t cdist3=0.55;
+ for (Int_t j =i+1;j<nentries;j++){
+ nall++;
+ if (sign[j]*sign[i]<1) continue;
+ if ( (nclusters[i]+nclusters[j])>200) continue;
+ if ( (nclusters[i]+nclusters[j])<80) continue;
+ if ( TMath::Abs(zm[i]-zm[j])>60.) continue;
+ if ( TMath::Abs(fim[i]-fim[j])>0.6 && TMath::Abs(fim[i]-fim[j])<5.7 ) continue;
+ //AliTPCseed * track1 = (AliTPCseed*)array->At(j); Double_t phase[2][2],radius[2];
+ Int_t npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
+ if (npoints<1) continue;
+ // cuts on radius
+ if (npoints==1){
+ if (radius[0]<cradius0||radius[0]>cradius1) continue;
+ }
+ else{
+ if ( (radius[0]<cradius0||radius[0]>cradius1) && (radius[1]<cradius0||radius[1]>cradius1) ) continue;
+ }
+ //
+ Double_t delta1=10000,delta2=10000;
+ // cuts on the intersection radius
+ helixes[i].LinearDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
+ if (radius[0]<20&&delta1<1) continue; //intersection at vertex
+ if (radius[0]<10&&delta1<3) continue; //intersection at vertex
+ if (npoints==2){
+ helixes[i].LinearDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);
+ if (radius[1]<20&&delta2<1) continue; //intersection at vertex
+ if (radius[1]<10&&delta2<3) continue; //intersection at vertex
+ }
+ //
+ Double_t distance1 = TMath::Min(delta1,delta2);
+ if (distance1>cdist1) continue; // cut on DCA linear approximation
+ //
+ npoints = helixes[i].GetRPHIintersections(helixes[j], phase, radius,20);
+ helixes[i].ParabolicDCA(helixes[j],phase[0][0],phase[0][1],radius[0],delta1);
+ if (radius[0]<20&&delta1<1) continue; //intersection at vertex
+ if (radius[0]<10&&delta1<3) continue; //intersection at vertex
+ //
+ if (npoints==2){
+ helixes[i].ParabolicDCA(helixes[j],phase[1][0],phase[1][1],radius[1],delta2);
+ if (radius[1]<20&&delta2<1) continue; //intersection at vertex
+ if (radius[1]<10&&delta2<3) continue; //intersection at vertex
+ }
+ distance1 = TMath::Min(delta1,delta2);
+ Float_t rkink =0;
+ if (delta1<delta2){
+ rkink = TMath::Sqrt(radius[0]);
+ }
+ else{
+ rkink = TMath::Sqrt(radius[1]);
+ }
+ if (distance1>cdist2) continue;
+ //
+ //
+ AliTPCseed * track1 = (AliTPCseed*)array->At(j);
+ //
+ //
+ Int_t row0 = GetRowNumber(rkink);
+ if (row0<10) continue;
+ if (row0>150) continue;
+ //
+ //
+ Float_t dens00=-1,dens01=-1;
+ Float_t dens10=-1,dens11=-1;
+ //
+ Int_t found,foundable,ishared;
+ track0->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
+ if (foundable>5) dens00 = Float_t(found)/Float_t(foundable);
+ track0->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
+ if (foundable>5) dens01 = Float_t(found)/Float_t(foundable);
+ //
+ track1->GetClusterStatistic(0,row0-5, found, foundable,ishared,kFALSE);
+ if (foundable>10) dens10 = Float_t(found)/Float_t(foundable);
+ track1->GetClusterStatistic(row0+5,155, found, foundable,ishared,kFALSE);
+ if (foundable>10) dens11 = Float_t(found)/Float_t(foundable);
+ //
+ if (dens00<dens10 && dens01<dens11) continue;
+ if (dens00>dens10 && dens01>dens11) continue;
+ if (TMath::Max(dens00,dens10)<0.1) continue;
+ if (TMath::Max(dens01,dens11)<0.3) continue;
+ //
+ if (TMath::Min(dens00,dens10)>0.6) continue;
+ if (TMath::Min(dens01,dens11)>0.6) continue;
+
+ //
+ AliTPCseed * ktrack0, *ktrack1;
+ if (dens00>dens10){
+ ktrack0 = track0;
+ ktrack1 = track1;
+ }
+ else{
+ ktrack0 = track1;
+ ktrack1 = track0;
+ }
+ 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().GetX()>90.)new (¶md) AliExternalTrackParam(ktrack1->GetReference());
+ //
+ //
+ kink->SetMother(paramm);
+ kink->SetDaughter(paramd);
+ kink->Update();
+
+ Float_t x[3] = { kink->GetPosition()[0],kink->GetPosition()[1],kink->GetPosition()[2]};
+ Int_t index[4];
+ fkParam->Transform0to1(x,index);
+ fkParam->Transform1to2(x,index);
+ row0 = GetRowNumber(x[0]);
+
+ if (kink->GetR()<100) continue;
+ if (kink->GetR()>240) continue;
+ if (kink->GetPosition()[2]/kink->GetR()>AliTPCReconstructor::GetCtgRange()) continue; //out of fiducial volume
+ if (kink->GetDistance()>cdist3) continue;
+ Float_t dird = kink->GetDaughterP()[0]*kink->GetPosition()[0]+kink->GetDaughterP()[1]*kink->GetPosition()[1]; // rough direction estimate
+ if (dird<0) continue;
+
+ Float_t dirm = kink->GetMotherP()[0]*kink->GetPosition()[0]+kink->GetMotherP()[1]*kink->GetPosition()[1]; // rough direction estimate
+ if (dirm<0) continue;
+ Float_t mpt = TMath::Sqrt(kink->GetMotherP()[0]*kink->GetMotherP()[0]+kink->GetMotherP()[1]*kink->GetMotherP()[1]);
+ if (mpt<0.2) continue;
+
+ if (mpt<1){
+ //for high momenta momentum not defined well in first iteration
+ Double_t qt = TMath::Sin(kink->GetAngle(2))*ktrack1->GetP();
+ if (qt>0.35) continue;
+ }
+
+ kink->SetLabel(CookLabel(ktrack0,0.4,0,row0),0);
+ kink->SetLabel(CookLabel(ktrack1,0.4,row0,160),1);
+ if (dens00>dens10){
+ kink->SetTPCDensity(dens00,0,0);
+ kink->SetTPCDensity(dens01,0,1);
+ kink->SetTPCDensity(dens10,1,0);
+ kink->SetTPCDensity(dens11,1,1);
+ kink->SetIndex(i,0);
+ kink->SetIndex(j,1);
+ }
+ else{
+ kink->SetTPCDensity(dens10,0,0);
+ kink->SetTPCDensity(dens11,0,1);
+ kink->SetTPCDensity(dens00,1,0);
+ kink->SetTPCDensity(dens01,1,1);
+ kink->SetIndex(j,0);
+ kink->SetIndex(i,1);
+ }
+
+ if (mpt<1||kink->GetAngle(2)>0.1){
+ // 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->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->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;
+ }
+ //
+ Int_t drow = Int_t(2.+0.5/(0.05+kink->GetAngle(2))); // overlap region defined
+ Float_t shapesum =0;
+ Float_t sum = 0;
+ for ( Int_t row = row0-drow; row<row0+drow;row++){
+ if (row<0) continue;
+ if (row>155) continue;
+ if (ktrack0->GetClusterPointer(row)){
+ AliTPCTrackerPoint *point =ktrack0->GetTrackPoint(row);
+ shapesum+=point->GetSigmaY()+point->GetSigmaZ();
+ sum++;
+ }
+ if (ktrack1->GetClusterPointer(row)){
+ AliTPCTrackerPoint *point =ktrack1->GetTrackPoint(row);
+ shapesum+=point->GetSigmaY()+point->GetSigmaZ();
+ sum++;
+ }
+ }
+ if (sum<4){
+ kink->SetShapeFactor(-1.);
+ }
+ else{
+ kink->SetShapeFactor(shapesum/sum);
+ }
+ // esd->AddKink(kink);
+ //
+ // kink->SetMother(paramm);
+ //kink->SetDaughter(paramd);
+
+ Double_t chi2P2 = paramm.GetParameter()[2]-paramd.GetParameter()[2];
+ chi2P2*=chi2P2;
+ chi2P2/=paramm.GetCovariance()[5]+paramd.GetCovariance()[5];
+ Double_t chi2P3 = paramm.GetParameter()[3]-paramd.GetParameter()[3];
+ chi2P3*=chi2P3;
+ chi2P3/=paramm.GetCovariance()[9]+paramd.GetCovariance()[9];
+ //
+ if (AliTPCReconstructor::StreamLevel()>1) {
+ (*fDebugStreamer)<<"kinkLpt"<<
+ "chi2P2="<<chi2P2<<
+ "chi2P3="<<chi2P3<<
+ "p0.="<<¶mm<<
+ "p1.="<<¶md<<
+ "k.="<<kink<<
+ "\n";
+ }
+ if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
+ continue;
+ }
+ //
+ kinks->AddLast(kink);
+ kink = new AliKink;
+ ncandidates++;
+ }
+ }
+ //
+ // sort the kinks according quality - and refit them towards vertex
+ //
+ Int_t nkinks = kinks->GetEntriesFast();
+ Float_t *quality = new Float_t[nkinks];
+ Int_t *indexes = new Int_t[nkinks];
+ AliTPCseed **mothers = new AliTPCseed*[nkinks]; memset(mothers, 0, nkinks*sizeof(AliTPCseed*));
+ AliTPCseed **daughters = new AliTPCseed*[nkinks]; memset(daughters, 0, nkinks*sizeof(AliTPCseed*));
+ //
+ //
+ for (Int_t i=0;i<nkinks;i++){
+ quality[i] =100000;
+ AliKink *kinkl = (AliKink*)kinks->At(i);
+ //
+ // refit kinks towards vertex
+ //
+ Int_t index0 = kinkl->GetIndex(0);
+ Int_t index1 = kinkl->GetIndex(1);
+ AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
+ AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
+ //
+ Int_t sumn=ktrack0->GetNumberOfClusters()+ktrack1->GetNumberOfClusters();
+ //
+ // Refit Kink under if too small angle
+ //
+ if (kinkl->GetAngle(2)<0.05){
+ kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
+ Int_t row0 = kinkl->GetTPCRow0();
+ Int_t drow = Int_t(2.+0.5/(0.05+kinkl->GetAngle(2)));
+ //
+ //
+ Int_t last = row0-drow;
+ if (last<40) last=40;
+ if (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->GetLastPoint()-25) first = TMath::Max(ktrack1->GetLastPoint()-25,30);
+ AliTPCseed* seed1 = ReSeed(ktrack1,first,kTRUE);
+ //
+ if (seed0 && seed1){
+ kinkl->SetStatus(1,8);
+ if (RefitKink(*seed0,*seed1,*kinkl)) kinkl->SetStatus(1,9);
+ row0 = GetRowNumber(kinkl->GetR());
+ sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
+ mothers[i] = new ( NextFreeSeed() ) AliTPCseed(*seed0);
+ mothers[i]->SetPoolID(fLastSeedID);
+ daughters[i] = new (NextFreeSeed() ) AliTPCseed(*seed1);
+ daughters[i]->SetPoolID(fLastSeedID);
+ }
+ else{
+ delete kinks->RemoveAt(i);
+ if (seed0) MarkSeedFree( seed0 );
+ if (seed1) MarkSeedFree( seed1 );
+ continue;
+ }
+ if (kinkl->GetDistance()>0.5 || kinkl->GetR()<110 || kinkl->GetR()>240) {
+ delete kinks->RemoveAt(i);
+ if (seed0) MarkSeedFree( seed0 );
+ if (seed1) MarkSeedFree( seed1 );
+ continue;
+ }
+ //
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
+ }
+ //
+ if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.); //the longest -clossest will win
+ }
+ TMath::Sort(nkinks,quality,indexes,kFALSE);
+ //
+ //remove double find kinks
+ //
+ for (Int_t ikink0=1;ikink0<nkinks;ikink0++){
+ AliKink * kink0 = (AliKink*) kinks->At(indexes[ikink0]);
+ if (!kink0) continue;
+ //
+ for (Int_t ikink1=0;ikink1<ikink0;ikink1++){
+ kink0 = (AliKink*) kinks->At(indexes[ikink0]);
+ if (!kink0) continue;
+ 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;
+ if (TMath::Abs(kink1->GetPosition()[1]-kink0->GetPosition()[1])>10) continue;
+ if (TMath::Abs(kink1->GetPosition()[0]-kink0->GetPosition()[0])>10) continue;
+ //
+ AliTPCseed &mother0 = *mothers[indexes[ikink0]];
+ AliTPCseed &daughter0 = *daughters[indexes[ikink0]];
+ AliTPCseed &mother1 = *mothers[indexes[ikink1]];
+ AliTPCseed &daughter1 = *daughters[indexes[ikink1]];
+ Int_t row0 = (kink0->GetTPCRow0()+kink1->GetTPCRow0())/2;
+ //
+ Int_t same = 0;
+ Int_t both = 0;
+ Int_t samem = 0;
+ Int_t bothm = 0;
+ Int_t samed = 0;
+ Int_t bothd = 0;
+ //
+ for (Int_t i=0;i<row0;i++){
+ if (mother0.GetClusterIndex(i)>0 && mother1.GetClusterIndex(i)>0){
+ both++;
+ bothm++;
+ if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
+ same++;
+ samem++;
+ }
+ }
+ }
+
+ for (Int_t i=row0;i<158;i++){
+ //if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){ // RS: Bug?
+ if (daughter0.GetClusterIndex(i)>0 && daughter1.GetClusterIndex(i)>0){
+ both++;
+ bothd++;
+ if (mother0.GetClusterIndex(i)==mother1.GetClusterIndex(i)){
+ same++;
+ samed++;
+ }
+ }
+ }
+ Float_t ratio = Float_t(same+1)/Float_t(both+1);
+ 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.GetNumberOfClusters()+daughter0.GetNumberOfClusters();
+ Int_t sum1 = mother1.GetNumberOfClusters()+daughter1.GetNumberOfClusters();
+ if (sum1>sum0){
+ shared[kink0->GetIndex(0)]= kTRUE;
+ shared[kink0->GetIndex(1)]= kTRUE;
+ delete kinks->RemoveAt(indexes[ikink0]);
+ break;
+ }
+ else{
+ shared[kink1->GetIndex(0)]= kTRUE;
+ shared[kink1->GetIndex(1)]= kTRUE;
+ delete kinks->RemoveAt(indexes[ikink1]);
+ }
+ }
+ }
+ }
+
+
+ for (Int_t i=0;i<nkinks;i++){
+ AliKink * kinkl = (AliKink*) kinks->At(indexes[i]);
+ if (!kinkl) continue;
+ kinkl->SetTPCRow0(GetRowNumber(kinkl->GetR()));
+ Int_t index0 = kinkl->GetIndex(0);
+ Int_t index1 = kinkl->GetIndex(1);
+ if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.2)) continue;
+ kinkl->SetMultiple(usage[index0],0);
+ kinkl->SetMultiple(usage[index1],1);
+ if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>2) continue;
+ if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && quality[indexes[i]]>0.2) continue;
+ if (kinkl->GetMultiple()[0]+kinkl->GetMultiple()[1]>0 && kinkl->GetDistance()>0.2) continue;
+ if (circular[index0]||(circular[index1]&&kinkl->GetDistance()>0.1)) continue;
+
+ AliTPCseed * ktrack0 = (AliTPCseed*)array->At(index0);
+ AliTPCseed * ktrack1 = (AliTPCseed*)array->At(index1);
+ if (!ktrack0 || !ktrack1) continue;
+ Int_t index = esd->AddKink(kinkl);
+ //
+ //
+ if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink
+ if (mothers[indexes[i]]->GetNumberOfClusters()>20 && daughters[indexes[i]]->GetNumberOfClusters()>20 &&
+ (mothers[indexes[i]]->GetNumberOfClusters()+daughters[indexes[i]]->GetNumberOfClusters())>100){
+ *ktrack0 = *mothers[indexes[i]];
+ *ktrack1 = *daughters[indexes[i]];
+ }
+ }
+ //
+ ktrack0->SetKinkIndex(usage[index0],-(index+1));
+ ktrack1->SetKinkIndex(usage[index1], (index+1));
+ usage[index0]++;
+ usage[index1]++;
+ }
+ //
+ // Remove tracks corresponding to shared kink's
+ //
+ for (Int_t i=0;i<nentries;i++){
+ AliTPCseed * track0 = (AliTPCseed*)array->At(i);
+ if (!track0) continue;
+ if (track0->GetKinkIndex(0)!=0) continue;
+ if (shared[i]) MarkSeedFree( array->RemoveAt(i) );
+ }
+
+ //
+ //
+ RemoveUsed2(array,0.5,0.4,30);
+ UnsignClusters();
+ for (Int_t i=0;i<nentries;i++){
+ AliTPCseed * track0 = (AliTPCseed*)array->At(i);
+ if (!track0) continue;
+ track0->CookdEdx(0.02,0.6);
+ track0->CookPID();
+ }
+ //
+ for (Int_t i=0;i<nentries;i++){
+ AliTPCseed * track0 = (AliTPCseed*)array->At(i);
+ if (!track0) continue;
+ if (track0->Pt()<1.4) continue;
+ //remove double high momenta tracks - overlapped with kink candidates
+ Int_t ishared=0;
+ Int_t all =0;
+ for (Int_t icl=track0->GetFirstPoint();icl<track0->GetLastPoint(); icl++){
+ if (track0->GetClusterPointer(icl)!=0){
+ all++;
+ if (track0->GetClusterPointer(icl)->IsUsed(10)) ishared++;
+ }
+ }
+ if (Float_t(ishared+1)/Float_t(all+1)>0.5) {
+ MarkSeedFree( array->RemoveAt(i) );
+ continue;
+ }
+ //
+ if (track0->GetKinkIndex(0)!=0) continue;
+ if (track0->GetNumberOfClusters()<80) continue;
+
+ AliTPCseed *pmother = new( NextFreeSeed() ) AliTPCseed();
+ pmother->SetPoolID(fLastSeedID);
+ AliTPCseed *pdaughter = new( NextFreeSeed() ) AliTPCseed();
+ pdaughter->SetPoolID(fLastSeedID);
+ AliKink *pkink = new AliKink;
+
+ AliTPCseed & mother = *pmother;
+ AliTPCseed & daughter = *pdaughter;
+ AliKink & kinkl = *pkink;
+ if (CheckKinkPoint(track0,mother,daughter, kinkl)){
+ if (mother.GetNumberOfClusters()<30||daughter.GetNumberOfClusters()<20) {
+ MarkSeedFree( pmother );
+ MarkSeedFree( pdaughter );
+ delete pkink;
+ continue; //too short tracks
+ }
+ if (mother.Pt()<1.4) {
+ MarkSeedFree( pmother );
+ MarkSeedFree( pdaughter );
+ delete pkink;
+ continue;
+ }
+ Int_t row0= kinkl.GetTPCRow0();
+ if (kinkl.GetDistance()>0.5 || kinkl.GetR()<110. || kinkl.GetR()>240.) {
+ MarkSeedFree( pmother );
+ MarkSeedFree( pdaughter );
+ delete pkink;
+ continue;
+ }
+ //
+ Int_t index = esd->AddKink(&kinkl);
+ mother.SetKinkIndex(0,-(index+1));
+ daughter.SetKinkIndex(0,index+1);
+ if (mother.GetNumberOfClusters()>50) {
+ MarkSeedFree( array->RemoveAt(i) );
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
+ array->AddAt(mtc,i);
+ }
+ else{
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
+ array->AddLast(mtc);
+ }
+ AliTPCseed* dtc = new( NextFreeSeed() ) AliTPCseed(daughter);
+ dtc->SetPoolID(fLastSeedID);
+ array->AddLast(dtc);
+ for (Int_t icl=0;icl<row0;icl++) {
+ if (mother.GetClusterPointer(icl)) mother.GetClusterPointer(icl)->Use(20);
+ }
+ //
+ for (Int_t icl=row0;icl<158;icl++) {
+ if (daughter.GetClusterPointer(icl)) daughter.GetClusterPointer(icl)->Use(20);
+ }
+ //
+ }
+ MarkSeedFree( pmother );
+ MarkSeedFree( pdaughter );
+ delete pkink;
+ }
+
+ delete [] daughters;
+ delete [] mothers;
+ //
+ //
+ delete [] dca;
+ delete []circular;
+ delete []shared;
+ delete []quality;
+ delete []indexes;
+ //
+ delete kink;
+ delete[]fim;
+ delete[] zm;
+ delete[] z0;
+ delete [] usage;
+ delete[] alpha;
+ delete[] nclusters;
+ delete[] sign;
+ delete[] helixes;
+ kinks->Delete();
+ delete kinks;
+
+ AliInfo(Form("Ncandidates=\t%d\t%d\t%d\t%d\n",esd->GetNumberOfKinks(),ncandidates,ntracks,nall));
+ timer.Print();
+}
+*/
+
+Int_t AliTPCtrackerMI::RefitKink(AliTPCseed &mother, AliTPCseed &daughter, const AliESDkink &knk)
+{
+ //
+ // refit kink towards to the vertex
+ //
+ //
+ AliKink &kink=(AliKink &)knk;
+
+ Int_t row0 = GetRowNumber(kink.GetR());
+ FollowProlongation(mother,0);
+ mother.Reset(kFALSE);
+ //
+ FollowProlongation(daughter,row0);
+ daughter.Reset(kFALSE);
+ FollowBackProlongation(daughter,158);
+ daughter.Reset(kFALSE);
+ Int_t first = TMath::Max(row0-20,30);
+ Int_t last = TMath::Min(row0+20,140);
+ //
+ const Int_t kNdiv =5;
+ AliTPCseed param0[kNdiv]; // parameters along the track
+ AliTPCseed param1[kNdiv]; // parameters along the track
+ AliKink kinks[kNdiv]; // corresponding kink parameters
+ //
+ Int_t rows[kNdiv];
+ for (Int_t irow=0; irow<kNdiv;irow++){
+ rows[irow] = first +((last-first)*irow)/(kNdiv-1);
+ }
+ // store parameters along the track
+ //
+ for (Int_t irow=0;irow<kNdiv;irow++){
+ FollowBackProlongation(mother, rows[irow]);
+ FollowProlongation(daughter,rows[kNdiv-1-irow]);
+ param0[irow] = mother;
+ param1[kNdiv-1-irow] = daughter;
+ }
+ //
+ // define kinks
+ for (Int_t irow=0; irow<kNdiv-1;irow++){
+ if (param0[irow].GetNumberOfClusters()<kNdiv||param1[irow].GetNumberOfClusters()<kNdiv) continue;
+ kinks[irow].SetMother(param0[irow]);
+ kinks[irow].SetDaughter(param1[irow]);
+ kinks[irow].Update();
+ }
+ //
+ // choose kink with best "quality"
+ Int_t index =-1;
+ Double_t mindist = 10000;
+ for (Int_t irow=0;irow<kNdiv;irow++){
+ 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].GetX()-kinks[irow].GetR())*(0.1+kink.GetDistance());
+ normdist/= (param0[irow].GetNumberOfClusters()+param1[irow].GetNumberOfClusters()+40.);
+ if (normdist < mindist){
+ mindist = normdist;
+ index = irow;
+ }
+ }
+ //
+ if (index==-1) return 0;
+ //
+ //
+ param0[index].Reset(kTRUE);
+ FollowProlongation(param0[index],0);
+ //
+ mother = param0[index];
+ daughter = param1[index]; // daughter in vertex
+ //
+ kink.SetMother(mother);
+ kink.SetDaughter(daughter);
+ kink.Update();
+ kink.SetTPCRow0(GetRowNumber(kink.GetR()));
+ kink.SetTPCncls(param0[index].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));
+ daughter.SetLabel(kink.GetLabel(1));
+
+ return 1;
+}
+
+
+void AliTPCtrackerMI::UpdateKinkQualityM(AliTPCseed * seed){
+ //
+ // update Kink quality information for mother after back propagation
+ //
+ if (seed->GetKinkIndex(0)>=0) return;
+ for (Int_t ikink=0;ikink<3;ikink++){
+ Int_t index = seed->GetKinkIndex(ikink);
+ if (index>=0) break;
+ index = TMath::Abs(index)-1;
+ AliESDkink * kink = fEvent->GetKink(index);
+ kink->SetTPCDensity(-1,0,0);
+ kink->SetTPCDensity(1,0,1);
+ //
+ Int_t row0 = kink->GetTPCRow0() - 2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
+ if (row0<15) row0=15;
+ //
+ Int_t row1 = kink->GetTPCRow0() + 2 + Int_t( 0.5/ (0.05+kink->GetAngle(2)));
+ if (row1>145) row1=145;
+ //
+ Int_t found,foundable,shared;
+ seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
+ if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,0);
+ seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
+ if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),0,1);
+ }
+
+}
+
+void AliTPCtrackerMI::UpdateKinkQualityD(AliTPCseed * seed){
+ //
+ // update Kink quality information for daughter after refit
+ //
+ if (seed->GetKinkIndex(0)<=0) return;
+ for (Int_t ikink=0;ikink<3;ikink++){
+ Int_t index = seed->GetKinkIndex(ikink);
+ if (index<=0) break;
+ index = TMath::Abs(index)-1;
+ AliESDkink * kink = fEvent->GetKink(index);
+ kink->SetTPCDensity(-1,1,0);
+ kink->SetTPCDensity(-1,1,1);
+ //
+ Int_t row0 = kink->GetTPCRow0() -2 - Int_t( 0.5/ (0.05+kink->GetAngle(2)));
+ if (row0<15) row0=15;
+ //
+ Int_t row1 = kink->GetTPCRow0() +2 + Int_t( 0.5/ (0.05+kink->GetAngle(2)));
+ if (row1>145) row1=145;
+ //
+ Int_t found,foundable,shared;
+ seed->GetClusterStatistic(0,row0, found, foundable,shared,kFALSE);
+ if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,0);
+ seed->GetClusterStatistic(row1,155, found, foundable,shared,kFALSE);
+ if (foundable>5) kink->SetTPCDensity(Float_t(found)/Float_t(foundable),1,1);
+ }
}
seed1->Reset(kTRUE);
last = seed1->GetLastPoint();
//
- AliTPCseed *seed0 = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(*seed);
- fSeedsPool->RegisterClone(seed0);
+ AliTPCseed *seed0 = new( NextFreeSeed() ) AliTPCseed(*seed);
+ seed0->SetPoolID(fLastSeedID);
seed0->Reset(kFALSE);
seed0->Reset();
//
//
}
}
- fSeedsPool->MarkSlotFree( seed0 );
- fSeedsPool->MarkSlotFree( seed1 );
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
if (index<0) return 0;
//
Int_t row0 = GetRowNumber(kinks[index].GetR()); //row 0 estimate
- seed0 = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(param0[index]);
- fSeedsPool->RegisterClone(seed0);
- seed1 = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(param1[index]);
- fSeedsPool->RegisterClone(seed1);
+ seed0 = new( NextFreeSeed() ) AliTPCseed(param0[index]);
+ seed0->SetPoolID(fLastSeedID);
+ seed1 = new( NextFreeSeed() ) AliTPCseed(param1[index]);
+ seed1->SetPoolID(fLastSeedID);
seed0->Reset(kFALSE);
seed1->Reset(kFALSE);
seed0->ResetCovariance(10.);
//
//
if (index==-1 || param0[index].GetNumberOfClusters()+param1[index].GetNumberOfClusters()<100){
- fSeedsPool->MarkSlotFree( seed0 );
- fSeedsPool->MarkSlotFree( seed1 );
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
return 0;
}
"\n";
}
if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
- fSeedsPool->MarkSlotFree( seed0 );
- fSeedsPool->MarkSlotFree( seed1 );
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
return 0;
}
if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(1)){
mother=*seed;
}
- fSeedsPool->MarkSlotFree( seed0 );
- fSeedsPool->MarkSlotFree( seed1 );
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
//
return 1;
}
Int_t n=(Int_t)seedTree->GetEntries();
for (Int_t i=0; i<n; i++) {
seedTree->GetEvent(i);
- AliTPCseed* sdc = new( fSeedsPool->NextFreeSlot() ) AliTPCseed(*seed/*,seed->GetAlpha()*/);
- fSeedsPool->RegisterClone(sdc);
+ AliTPCseed* sdc = new( NextFreeSeed() ) AliTPCseed(*seed/*,seed->GetAlpha()*/);
+ sdc->SetPoolID(fLastSeedID);
fSeeds->AddLast(sdc);
}
{
//
// clusters to tracks
- if (fPools && !fPools->GetPoolTPCSeed()) fPools->SetPool(fSeedsPool,AliPoolsSet::kPoolTPCSeed);
if (fSeeds) DeleteSeeds();
- else fSeedsPool->Clear("C");
+ else ResetSeedsPool();
fEvent = esd;
AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<20) {
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
CookLabel(pt,0.1);
pt->Desactivate(10); // make track again active // MvL: should be 0 ?
else{
pt->Desactivate(20);
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
}
}
}
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
CookLabel(pt,0.1); //For comparison only
pt->SetLab2(i);
}
else
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
}
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
t.SetUniqueID(i);
pt->SetLab2(i);
}
else
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
//AliTPCseed * seed1 = ReSeed(pt,0.05,0.5,1);
//if (seed1){
// FollowProlongation(*seed1,0);
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
t.CookdEdx(0.02,0.6);
cerr<<found++<<'\r';
}
else
- fSeedsPool->MarkSlotFree( fSeeds->RemoveAt(i) );
+ MarkSeedFree( fSeeds->RemoveAt(i) );
pt->fLab2 = i;
}
*/
// remove tracks with too big curvature
//
if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){
- fSeedsPool->MarkSlotFree( arr2->RemoveAt(i) );
+ MarkSeedFree( arr2->RemoveAt(i) );
continue;
}
// REMOVE VERY SHORT TRACKS
if (pt->GetNumberOfClusters()<20){
- fSeedsPool->MarkSlotFree( arr2->RemoveAt(i) );
+ MarkSeedFree( arr2->RemoveAt(i) );
continue;
}// patch 28 fev06
// NORMAL ACTIVE TRACK
}
//remove not usable tracks
if (pt->GetRemoval()!=10){
- fSeedsPool->MarkSlotFree( arr2->RemoveAt(i) );
+ MarkSeedFree( arr2->RemoveAt(i) );
continue;
}
if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
arr1->AddLast(arr2->RemoveAt(i));
else{
- fSeedsPool->MarkSlotFree( arr2->RemoveAt(i) );
+ MarkSeedFree( arr2->RemoveAt(i) );
}
}
}
void AliTPCtrackerMI::AddCovariance(AliTPCseed * seed){
//
// Adding systematic error estimate to the covariance matrix
- // !!!! the systematic error for element 4 is in 1/cm not in pt
- //
+ // !!!! the systematic error for element 4 is in 1/GeV
+ // 03.03.2012 MI changed in respect to the previous versions
const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
//
// use only the diagonal part if not specified otherwise
//
Double_t *covarS= (Double_t*)seed->GetCovariance();
Double_t factor[5]={1,1,1,1,1};
- Double_t facC = AliTracker::GetBz()*kB2C;
factor[0]= TMath::Sqrt(TMath::Abs((covarS[0] + param[0]*param[0])/covarS[0]));
factor[1]= TMath::Sqrt(TMath::Abs((covarS[2] + param[1]*param[1])/covarS[2]));
factor[2]= TMath::Sqrt(TMath::Abs((covarS[5] + param[2]*param[2])/covarS[5]));
factor[3]= TMath::Sqrt(TMath::Abs((covarS[9] + param[3]*param[3])/covarS[9]));
- factor[4]= TMath::Sqrt(TMath::Abs((covarS[14] + facC*facC*param[4]*param[4])/covarS[14]));
+ factor[4]= TMath::Sqrt(TMath::Abs((covarS[14] +param[4]*param[4])/covarS[14]));
+ //
+ factor[0]=factor[2];
+ factor[4]=factor[2];
// 0
// 1 2
// 3 4 5
//
// Adding systematic error - as additive factor without correlation
//
+ // !!!! the systematic error for element 4 is in 1/GeV
+ // 03.03.2012 MI changed in respect to the previous versions
+
const Double_t *param = AliTPCReconstructor::GetRecoParam()->GetSystematicError();
Double_t *covarIn= (Double_t*)seed->GetCovariance();
Double_t covar[15];
covar[2] = param[1]*param[1];
covar[5] = param[2]*param[2];
covar[9] = param[3]*param[3];
- Double_t facC = AliTracker::GetBz()*kB2C;
- covar[14]= param[4]*param[4]*facC*facC;
+ covar[14]= param[4]*param[4];
//
covar[1]=TMath::Sqrt((covar[0]*covar[2]))*covarIn[1]/TMath::Sqrt((covarIn[0]*covarIn[2]));
//
seed->AddCovariance(covar);
}
+//_____________________________________________________________________________
+Bool_t AliTPCtrackerMI::IsTPCHVDipEvent(AliESDEvent const *esdEvent) {
+//
+// check events affected by TPC HV dip
+//
+if(!esdEvent) return kFALSE;
+
+// Init TPC OCDB
+if(!AliTPCcalibDB::Instance()) return kFALSE;
+AliTPCcalibDB::Instance()->SetRun(esdEvent->GetRunNumber());
+
+// Get HV TPC chamber sensors and calculate the median
+AliDCSSensorArray *voltageArray= AliTPCcalibDB::Instance()->GetVoltageSensors(esdEvent->GetRunNumber());
+if(!voltageArray) return kFALSE;
+
+TString sensorName="";
+Double_t kTPCHVdip = 2.0; // allow for 2V dip as compared to median from given sensor
+
+
+ for(Int_t sector=0; sector<72; sector++)
+ {
+ Char_t sideName='A';
+ if ((sector/18)%2==1) sideName='C';
+ if (sector<36){
+ //IROC
+ sensorName=Form("TPC_ANODE_I_%c%02d_VMEAS",sideName,sector%18);
+ } else {
+ //OROC
+ sensorName=Form("TPC_ANODE_O_%c%02d_0_VMEAS",sideName,sector%18);
+ }
+
+ AliDCSSensor* sensor = voltageArray->GetSensor(sensorName.Data());
+ if(!sensor) continue;
+ TGraph *graph = sensor->GetGraph();
+ if(!graph) continue;
+ Double_t median = TMath::Median(graph->GetN(), graph->GetY());
+ if(median == 0) continue;
+
+ //printf("chamber %d, sensor %s, HV %f, median %f\n", sector, sensorName.Data(), sensor->GetValue(esdEvent->GetTimeStamp()), median);
+
+ if(TMath::Abs(sensor->GetValue(esdEvent->GetTimeStamp())-median)>kTPCHVdip) {
+ return kTRUE;
+ }
+ }
+
+ return kFALSE;
+}
+
+//________________________________________
+void AliTPCtrackerMI::MarkSeedFree(TObject *sd)
+{
+ // account that this seed is "deleted"
+ AliTPCseed* seed = dynamic_cast<AliTPCseed*>(sd);
+ if (!seed) {
+ AliError(Form("Freeing of non-AliTPCseed %p from the pool is requested",sd));
+ return;
+ }
+ int id = seed->GetPoolID();
+ if (id<0) {
+ AliError(Form("Freeing of seed %p NOT from the pool is requested",sd));
+ return;
+ }
+ // AliInfo(Form("%d %p",id, seed));
+ fSeedsPool->RemoveAt(id);
+ if (fFreeSeedsID.GetSize()<=fNFreeSeeds) fFreeSeedsID.Set( 2*fNFreeSeeds + 100 );
+ fFreeSeedsID.GetArray()[fNFreeSeeds++] = id;
+}
+
+//________________________________________
+TObject *&AliTPCtrackerMI::NextFreeSeed()
+{
+ // return next free slot where the seed can be created
+ fLastSeedID = fNFreeSeeds ? fFreeSeedsID.GetArray()[--fNFreeSeeds] : fSeedsPool->GetEntriesFast();
+ // AliInfo(Form("%d",fLastSeedID));
+ return (*fSeedsPool)[ fLastSeedID ];
+ //
+}
+
+//________________________________________
+void AliTPCtrackerMI::ResetSeedsPool()
+{
+ // mark all seeds in the pool as unused
+ AliInfo(Form("CurrentSize: %d, BookedUpTo: %d, free: %d",fSeedsPool->GetSize(),fSeedsPool->GetEntriesFast(),fNFreeSeeds));
+ fNFreeSeeds = 0;
+ fSeedsPool->Clear("C"); // RS: nominally the seeds may allocate memory...
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff