// 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 "AliTPCcalibDButil.h"
#include "AliTPCTransform.h"
#include "AliTPCClusterParam.h"
+#include "AliTPCdEdxInfo.h"
+#include "AliDCSSensorArray.h"
+#include "AliDCSSensor.h"
+#include "AliDAQ.h"
+#include "AliCosmicTracker.h"
//
+using std::cerr;
+using std::endl;
ClassImp(AliTPCtrackerMI)
fSeeds(0),
fIteration(0),
fkParam(0),
- fDebugStreamer(0)
+ fDebugStreamer(0),
+ fUseHLTClusters(4),
+ fSeedsPool(0),
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//
// default constructor
AliTPCclusterMI* c =track->GetCurrentCluster();
- if (accept>0) track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000); //sign not accepted clusters
-
+ if (accept > 0) //sign not accepted clusters
+ track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() | 0x8000);
+ else // unsign accpeted clusters
+ track->SetCurrentClusterIndex1(track->GetCurrentClusterIndex1() & 0xffff7fff);
UInt_t i = track->GetCurrentClusterIndex1();
Int_t sec=(i&0xff000000)>>24;
seed->SetNFoundable(seed->GetNFoundable()-1);
return 2;
}
+
+ if (fUseHLTClusters == 3 || fUseHLTClusters == 4) {
+ if (fIteration==2){
+ if(!AliTPCReconstructor::GetRecoParam()->GetUseHLTOnePadCluster()) {
+ if (TMath::Abs(cluster->GetSigmaY2()) < kAlmost0)
+ return 2;
+ }
+ }
+ }
+
return 0;
}
fSeeds(0),
fIteration(0),
fkParam(0),
- fDebugStreamer(0)
+ fDebugStreamer(0),
+ fUseHLTClusters(4),
+ fSeedsPool(0),
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//---------------------------------------------------------------------
// The main TPC tracker constructor
if (AliTPCReconstructor::StreamLevel()>0) {
fDebugStreamer = new TTreeSRedirector("TPCdebug.root");
}
+ //
+ fSeedsPool = new TClonesArray("AliTPCseed",1000);
}
//________________________________________________________________________
AliTPCtrackerMI::AliTPCtrackerMI(const AliTPCtrackerMI &t):
fSeeds(0),
fIteration(0),
fkParam(0),
- fDebugStreamer(0)
+ fDebugStreamer(0),
+ fUseHLTClusters(4),
+ fSeedsPool(0),
+ fFreeSeedsID(500),
+ fNFreeSeeds(0),
+ fLastSeedID(-1)
{
//------------------------------------
// dummy copy constructor
//------------------------------------------------------------------
fOutput=t.fOutput;
+ for (Int_t irow=0; irow<200; irow++){
+ fXRow[irow]=0;
+ fYMax[irow]=0;
+ fPadLength[irow]=0;
+ }
+
}
AliTPCtrackerMI & AliTPCtrackerMI::operator=(const AliTPCtrackerMI& /*r*/)
{
delete[] fInnerSec;
delete[] fOuterSec;
if (fSeeds) {
- fSeeds->Delete();
+ fSeeds->Clear();
delete fSeeds;
}
if (fDebugStreamer) delete fDebugStreamer;
+ if (fSeedsPool) delete fSeedsPool;
}
Int_t AliTPCtrackerMI::LoadClusters (TTree *const tree)
{
- //
+ // load clusters
//
fInput = tree;
return LoadClusters();
}
if (left ==0){
tpcrow->SetN1(clrow->GetArray()->GetEntriesFast());
- tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]);
for (Int_t j=0;j<tpcrow->GetN1();++j)
tpcrow->SetCluster1(j, *(AliTPCclusterMI*)(clrow->GetArray()->At(j)));
}
if (left ==1){
tpcrow->SetN2(clrow->GetArray()->GetEntriesFast());
- tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]);
for (Int_t j=0;j<tpcrow->GetN2();++j)
- tpcrow->SetCluster2(j,*(AliTPCclusterMI*)(clrow->GetArray()->At(j)));
+ tpcrow->SetCluster2(j, *(AliTPCclusterMI*)(clrow->GetArray()->At(j)));
}
clrow->GetArray()->Clear("C");
}
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);
}
}
{
//
// load clusters to the memory
- AliTPCClustersRow *clrow= new AliTPCClustersRow("AliTPCclusterMI");
+ static AliTPCClustersRow *clrow= new AliTPCClustersRow("AliTPCclusterMI");
//
// TTree * tree = fClustersArray.GetTree();
TTree * tree = fInput;
TBranch * br = tree->GetBranch("Segment");
br->SetAddress(&clrow);
- //
+
+ // Conversion of pad, row coordinates in local tracking coords.
+ // Could be skipped here; is already done in clusterfinder
+
Int_t j=Int_t(tree->GetEntries());
for (Int_t i=0; i<j; i++) {
br->GetEntry(i);
}
if (left ==0){
tpcrow->SetN1(clrow->GetArray()->GetEntriesFast());
- tpcrow->SetClusters1(new AliTPCclusterMI[tpcrow->GetN1()]);
for (Int_t k=0;k<tpcrow->GetN1();++k)
tpcrow->SetCluster1(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k)));
}
if (left ==1){
tpcrow->SetN2(clrow->GetArray()->GetEntriesFast());
- tpcrow->SetClusters2(new AliTPCclusterMI[tpcrow->GetN2()]);
for (Int_t k=0;k<tpcrow->GetN2();++k)
- tpcrow->SetCluster2(k,*(AliTPCclusterMI*)(clrow->GetArray()->At(k)));
+ tpcrow->SetCluster2(k, *(AliTPCclusterMI*)(clrow->GetArray()->At(k)));
}
}
//
- delete clrow;
+ clrow->Clear("C");
LoadOuterSectors();
LoadInnerSectors();
return 0;
void AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
//
+ // transformation
//
- //
- AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
+ AliTPCcalibDB * calibDB = AliTPCcalibDB::Instance();
+ AliTPCTransform *transform = calibDB->GetTransform() ;
if (!transform) {
AliFatal("Tranformations not in calibDB");
return;
cluster->SetY(x[1]);
cluster->SetZ(x[2]);
// The old stuff:
-
//
//
//
//if (!fkParam->IsGeoRead()) fkParam->ReadGeoMatrices();
- TGeoHMatrix *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
- //TGeoHMatrix mat;
- Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
- Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
- if (mat) mat->LocalToMaster(pos,posC);
- else{
- // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
- }
- cluster->SetX(posC[0]);
- cluster->SetY(posC[1]);
- cluster->SetZ(posC[2]);
+ if (AliTPCReconstructor::GetRecoParam()->GetUseSectorAlignment() && (!calibDB->HasAlignmentOCDB())){
+ TGeoHMatrix *mat = fkParam->GetClusterMatrix(cluster->GetDetector());
+ //TGeoHMatrix mat;
+ Double_t pos[3]= {cluster->GetX(),cluster->GetY(),cluster->GetZ()};
+ Double_t posC[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
+ if (mat) mat->LocalToMaster(pos,posC);
+ else{
+ // chack Loading of Geo matrices from GeoManager - TEMPORARY FIX
+ }
+ cluster->SetX(posC[0]);
+ cluster->SetY(posC[1]);
+ cluster->SetZ(posC[2]);
+ }
}
//_____________________________________________________________________________
Int_t ncl=(index&0x00007fff)>>00;
const AliTPCtrackerRow * tpcrow=0;
- AliTPCclusterMI * clrow =0;
+ TClonesArray * clrow =0;
if (sec<0 || sec>=fkNIS*4) {
AliWarning(Form("Wrong sector %d",sec));
}
}
- return &(clrow[ncl]);
+ return (AliTPCclusterMI*)clrow->At(ncl);
}
if (fIteration>0 && tpcindex>=-1){ //if we have already clusters
//
if (tpcindex==-1) return 0; //track in dead zone
- if (tpcindex>0){ //
+ if (tpcindex >= 0){ //
cl = t.GetClusterPointer(nr);
- if ( (cl==0) ) cl = GetClusterMI(tpcindex);
+ //if (cl==0) cl = GetClusterMI(tpcindex);
+ if (!cl) cl = GetClusterMI(tpcindex);
t.SetCurrentClusterIndex1(tpcindex);
}
if (cl){
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);
t.SetNFoundable(t.GetNFoundable()+1);
UpdateTrack(&t,accept);
return 1;
- }
+ }
+ else { // Remove old cluster from track
+ t.SetClusterIndex(nr, -3);
+ t.SetClusterPointer(nr, 0);
+ }
}
}
if (TMath::Abs(t.GetSnp())>AliTPCReconstructor::GetMaxSnpTracker()) return 0; // cut on angle
//
UInt_t index=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 (!t.PropagateTo(x)) {
+ if (fIteration==0) t.SetRemoval(10);
+ return 0;
+ }
+ Double_t y = t.GetY();
if (TMath::Abs(y)>ymax){
if (y > ymax) {
t.SetRelativeSector((t.GetRelativeSector()+1) % fN);
if (!t.Rotate(-fSectors->GetAlpha()))
return 0;
}
- //return 1;
+ if (!t.PropagateTo(x)) {
+ if (fIteration==0) t.SetRemoval(10);
+ return 0;
+ }
+ y = t.GetY();
}
//
- if (!t.PropagateTo(x)) {
- if (fIteration==0) t.SetRemoval(10);
- return 0;
- }
- y=t.GetY();
Double_t z=t.GetZ();
//
// This function tries to find a track prolongation to next pad row
//-----------------------------------------------------------------
t.SetCurrentCluster(0);
- t.SetCurrentClusterIndex1(0);
+ t.SetCurrentClusterIndex1(-3);
Double_t xt=t.GetX();
Int_t row = GetRowNumber(xt)-1;
if (!cl){
index = t.GetClusterIndex2(nr);
- if ( (index>0) && (index&0x8000)==0){
+ if ( (index >= 0) && (index&0x8000)==0){
cl = t.GetClusterPointer(nr);
- if ( (cl==0) && (index>0)) cl = GetClusterMI(index);
+ if ( (cl==0) && (index >= 0)) cl = GetClusterMI(index);
t.SetCurrentClusterIndex1(index);
if (cl) {
t.SetCurrentCluster(cl);
} else {
if (fIteration==0){
- if ( ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)&& t.GetNumberOfClusters()>18) t.SetRemoval(10);
- if ( t.GetChi2()/t.GetNumberOfClusters()>6 &&t.GetNumberOfClusters()>18) t.SetRemoval(10);
+ if ( t.GetNumberOfClusters()>18 && ( (t.GetSigmaY2()+t.GetSigmaZ2())>0.16)) t.SetRemoval(10);
+ if ( t.GetNumberOfClusters()>18 && t.GetChi2()/t.GetNumberOfClusters()>6 ) t.SetRemoval(10);
if (( (t.GetNFoundable()*0.5 > t.GetNumberOfClusters()) || t.GetNoCluster()>15)) t.SetRemoval(10);
}
//_____________________________________________________________________________
-Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step) {
+Int_t AliTPCtrackerMI::FollowProlongation(AliTPCseed& t, Int_t rf, Int_t step, Bool_t fromSeeds) {
//-----------------------------------------------------------------
// This function tries to find a track prolongation.
//-----------------------------------------------------------------
Double_t xt=t.GetX();
//
- Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
+ Double_t alpha=t.GetAlpha();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
//
t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
- Int_t first = GetRowNumber(xt)-1;
+ Int_t first = GetRowNumber(xt);
+ if (!fromSeeds)
+ first -= step;
+ if (first < 0)
+ first = 0;
for (Int_t nr= first; nr>=rf; nr-=step) {
// update kink info
if (t.GetKinkIndexes()[0]>0){
-Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf) {
+Int_t AliTPCtrackerMI::FollowBackProlongation(AliTPCseed& t, Int_t rf, Bool_t fromSeeds) {
//-----------------------------------------------------------------
// This function tries to find a track prolongation.
//-----------------------------------------------------------------
//
Double_t xt=t.GetX();
- Double_t alpha=t.GetAlpha() - fSectors->GetAlphaShift();
+ Double_t alpha=t.GetAlpha();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
t.SetRelativeSector(Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN);
Int_t first = t.GetFirstPoint();
- if (first<GetRowNumber(xt)+1) first = GetRowNumber(xt)+1;
+ Int_t ri = GetRowNumber(xt);
+ if (!fromSeeds)
+ ri += 1;
+
+ if (first<ri) first = ri;
//
if (first<0) first=0;
for (Int_t nr=first; nr<=rf; nr++) {
Float_t AliTPCtrackerMI::OverlapFactor(AliTPCseed * s1, AliTPCseed * s2, Int_t &sum1, Int_t & sum2)
{
- //
+ // overlapping factor
//
sum1=0;
sum2=0;
void AliTPCtrackerMI::SignShared(AliTPCseed * s1, AliTPCseed * s2)
{
- //
+ // shared clusters
//
Float_t thetaCut = 0.2;//+10.*TMath::Sqrt(s1->GetSigmaTglZ()+ s2->GetSigmaTglZ());
if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>thetaCut) return;
// if ( (s1->GetClusterIndex2(i)&0xFFFF8FFF)==(s2->GetClusterIndex2(i)&0xFFFF8FFF) && s1->GetClusterIndex2(i)>0) {
if ( (s1->GetClusterIndex2(i))==(s2->GetClusterIndex2(i)) && s1->GetClusterIndex2(i)>0) {
sumshared++;
- s1->SetSharedMapBit(i, kTRUE);
- s2->SetSharedMapBit(i, kTRUE);
}
- if (s1->GetClusterIndex2(i)>0)
- s1->SetClusterMapBit(i, kTRUE);
}
if (sumshared>cutN0){
// sign clusters
if (!pt) continue;
//
if (quality[trackindex]<0){
- delete arr->RemoveAt(trackindex);
- continue;
+ MarkSeedFree( arr->RemoveAt(trackindex) );
+ continue;
}
//
//
"pt.="<<pt<<
"\n";
}
- delete arr->RemoveAt(trackindex);
+ MarkSeedFree( arr->RemoveAt(trackindex) );
continue;
}
if (pt->GetNumberOfClusters()<50&&(found-0.5*shared)<minimal){ //remove short tracks
"pt.="<<pt<<
"\n";
}
- delete arr->RemoveAt(trackindex);
+ MarkSeedFree( arr->RemoveAt(trackindex) );
continue;
}
}
for (Int_t sec=0;sec<fkNIS;sec++){
for (Int_t row=0;row<fInnerSec->GetNRows();row++){
- AliTPCclusterMI *cl = fInnerSec[sec][row].GetClusters1();
+ TClonesArray *cla = fInnerSec[sec][row].GetClusters1();
for (Int_t icl =0;icl< fInnerSec[sec][row].GetN1();icl++){
- Float_t gx[3]; cl[icl].GetGlobalXYZ(gx);
+ AliTPCclusterMI* cl = (AliTPCclusterMI*)cla->At(icl);
+ Float_t gx[3]; cl->GetGlobalXYZ(gx);
(*fDebugStreamer)<<"clDump"<<
"iter="<<iter<<
- "cl.="<<&cl[icl]<<
+ "cl.="<<cl<<
"gx0="<<gx[0]<<
"gx1="<<gx[1]<<
"gx2="<<gx[2]<<
"\n";
}
- cl = fInnerSec[sec][row].GetClusters2();
+ cla = fInnerSec[sec][row].GetClusters2();
for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++){
- Float_t gx[3]; cl[icl].GetGlobalXYZ(gx);
+ AliTPCclusterMI* cl = (AliTPCclusterMI*)cla->At(icl);
+ Float_t gx[3]; cl->GetGlobalXYZ(gx);
(*fDebugStreamer)<<"clDump"<<
"iter="<<iter<<
- "cl.="<<&cl[icl]<<
+ "cl.="<<cl<<
"gx0="<<gx[0]<<
"gx1="<<gx[1]<<
"gx2="<<gx[2]<<
for (Int_t sec=0;sec<fkNOS;sec++){
for (Int_t row=0;row<fOuterSec->GetNRows();row++){
- AliTPCclusterMI *cl = fOuterSec[sec][row].GetClusters1();
+ TClonesArray *cla = fOuterSec[sec][row].GetClusters1();
for (Int_t icl =0;icl< fOuterSec[sec][row].GetN1();icl++){
- Float_t gx[3]; cl[icl].GetGlobalXYZ(gx);
+ Float_t gx[3];
+ AliTPCclusterMI* cl = (AliTPCclusterMI*) cla->At(icl);
+ cl->GetGlobalXYZ(gx);
(*fDebugStreamer)<<"clDump"<<
"iter="<<iter<<
- "cl.="<<&cl[icl]<<
+ "cl.="<<cl<<
"gx0="<<gx[0]<<
"gx1="<<gx[1]<<
"gx2="<<gx[2]<<
"\n";
}
- cl = fOuterSec[sec][row].GetClusters2();
+ cla = fOuterSec[sec][row].GetClusters2();
for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++){
- Float_t gx[3]; cl[icl].GetGlobalXYZ(gx);
+ Float_t gx[3];
+ AliTPCclusterMI* cl = (AliTPCclusterMI*) cla->At(icl);
+ cl->GetGlobalXYZ(gx);
(*fDebugStreamer)<<"clDump"<<
"iter="<<iter<<
- "cl.="<<&cl[icl]<<
+ "cl.="<<cl<<
"gx0="<<gx[0]<<
"gx1="<<gx[1]<<
"gx2="<<gx[2]<<
for (Int_t sec=0;sec<fkNIS;sec++){
for (Int_t row=0;row<fInnerSec->GetNRows();row++){
- AliTPCclusterMI *cl = fInnerSec[sec][row].GetClusters1();
+ TClonesArray *cla = 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].GetClusters2();
+ ((AliTPCclusterMI*) cla->At(icl))->Use(-1);
+ cla = fInnerSec[sec][row].GetClusters2();
for (Int_t icl =0;icl< fInnerSec[sec][row].GetN2();icl++)
//if (cl[icl].IsUsed(10))
- cl[icl].Use(-1);
+ ((AliTPCclusterMI*) cla->At(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].GetClusters1();
+ TClonesArray *cla = 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].GetClusters2();
+ ((AliTPCclusterMI*) cla->At(icl))->Use(-1);
+ cla = fOuterSec[sec][row].GetClusters2();
for (Int_t icl =0;icl< fOuterSec[sec][row].GetN2();icl++)
//if (cl[icl].IsUsed(10))
- cl[icl].Use(-1);
+ ((AliTPCclusterMI*) cla->At(icl))->Use(-1);
}
}
pt->GetClusterStatistic(0,160,found, foundable,shared);
if (shared/float(found)>0.3) {
if (shared/float(found)>0.9 ){
- //delete arr->RemoveAt(i);
+ //MarkSeedFree( arr->RemoveAt(i) );
}
continue;
}
}
-void AliTPCtrackerMI::StopNotActive(const TObjArray * arr, Int_t row0, Float_t th0, Float_t th1, Float_t th2) const
-{
- // stop not active tracks
- // take th1 as threshold for number of founded to number of foundable on last 10 active rows
- // take th2 as threshold for number of founded to number of foundable on last 20 active rows
- Int_t nseed = arr->GetEntriesFast();
- //
- for (Int_t i=0; i<nseed; i++) {
- AliTPCseed *pt=(AliTPCseed*)arr->UncheckedAt(i);
- if (!pt) {
- continue;
- }
- if (!(pt->IsActive())) continue;
- StopNotActive(pt,row0,th0, th1,th2);
- }
-}
-
-
-
-void AliTPCtrackerMI::StopNotActive(AliTPCseed * seed, Int_t row0, Float_t th0, Float_t th1,
- Float_t th2) const
-{
- // stop not active tracks
- // take th1 as threshold for number of founded to number of foundable on last 10 active rows
- // take th2 as threshold for number of founded to number of foundable on last 20 active rows
- Int_t sumgood1 = 0;
- Int_t sumgood2 = 0;
- Int_t foundable = 0;
- Int_t maxindex = seed->GetLastPoint(); //last foundable row
- if (seed->GetNFoundable()*th0 > seed->GetNumberOfClusters()) {
- seed->Desactivate(10) ;
- return;
- }
-
- for (Int_t i=row0; i<maxindex; i++){
- Int_t index = seed->GetClusterIndex2(i);
- if (index!=-1) foundable++;
- //if (!c) continue;
- if (foundable<=30) sumgood1++;
- if (foundable<=50) {
- sumgood2++;
- }
- else{
- break;
- }
- }
- if (foundable>=30.){
- if (sumgood1<(th1*30.)) seed->Desactivate(10);
- }
- if (foundable>=50)
- if (sumgood2<(th2*50.)) seed->Desactivate(10);
-}
-
Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
{
fEvent = event;
// extract correction object for multiplicity dependence of dEdx
TObjArray * gainCalibArray = AliTPCcalibDB::Instance()->GetTimeGainSplinesRun(event->GetRunNumber());
+
+ AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
+ if (!transform) {
+ AliFatal("Tranformations not in RefitInward");
+ return 0;
+ }
+ transform->SetCurrentRecoParam((AliTPCRecoParam*)AliTPCReconstructor::GetRecoParam());
const AliTPCRecoParam * recoParam = AliTPCcalibDB::Instance()->GetTransform()->GetCurrentRecoParam();
+ Int_t nContribut = event->GetNumberOfTracks();
TGraphErrors * graphMultDependenceDeDx = 0x0;
- if (recoParam->GetUseMultiplicityCorrectionDedx()) {
+ if (recoParam && recoParam->GetUseMultiplicityCorrectionDedx() && gainCalibArray) {
if (recoParam->GetUseTotCharge()) {
graphMultDependenceDeDx = (TGraphErrors *) gainCalibArray->FindObject("TGRAPHERRORS_MEANQTOT_MULTIPLICITYDEPENDENCE_BEAM_ALL");
} else {
seed->PropagateTo(fkParam->GetInnerRadiusLow());
seed->UpdatePoints();
AddCovariance(seed);
- MakeBitmaps(seed);
+ MakeESDBitmaps(seed, esd);
seed->CookdEdx(0.02,0.6);
CookLabel(seed,0.1); //For comparison only
- esd->SetTPCClusterMap(seed->GetClusterMap());
- esd->SetTPCSharedMap(seed->GetSharedMap());
//
if (AliTPCReconstructor::StreamLevel()>1 && seed!=0) {
TTreeSRedirector &cstream = *fDebugStreamer;
Float_t dedx = seed->GetdEdx();
// apply mutliplicity dependent dEdx correction if available
if (graphMultDependenceDeDx) {
- Int_t nContribut = event->GetPrimaryVertexTPC()->GetNContributors();
Double_t corrGain = AliTPCcalibDButil::EvalGraphConst(graphMultDependenceDeDx, nContribut);
- dedx /= corrGain;
+ dedx += (1 - corrGain)*50.; // MIP is normalized to 50
}
esd->SetTPCsignal(dedx, sdedx, ndedx);
//
+ // fill new dEdx information
+ //
+ Double32_t signal[4];
+ Char_t ncl[3];
+ Char_t nrows[3];
+ //
+ for(Int_t iarr=0;iarr<3;iarr++) {
+ signal[iarr] = seed->GetDEDXregion(iarr+1);
+ ncl[iarr] = seed->GetNCDEDX(iarr+1);
+ nrows[iarr] = seed->GetNCDEDXInclThres(iarr+1);
+ }
+ signal[3] = seed->GetDEDXregion(4);
+ //
+ AliTPCdEdxInfo * infoTpcPid = new AliTPCdEdxInfo();
+ infoTpcPid->SetTPCSignalRegionInfo(signal, ncl, nrows);
+ esd->SetTPCdEdxInfo(infoTpcPid);
+ //
// add seed to the esd track in Calib level
//
Bool_t storeFriend = gRandom->Rndm()<(kMaxFriendTracks)/Float_t(nseed);
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);
}
//FindKinks(fSeeds,event);
if (AliTPCReconstructor::StreamLevel()>3) DumpClusters(2,fSeeds);
Info("RefitInward","Number of refitted tracks %d",ntracks);
+
+ AliCosmicTracker::FindCosmic(event, kTRUE);
+
return 0;
}
seed->UpdatePoints();
AddCovariance(seed);
AliESDtrack *esd=event->GetTrack(i);
+ if (!esd) continue; //never happen
if (seed->GetNumberOfClusters()<60 && seed->GetNumberOfClusters()<(esd->GetTPCclusters(0) -5)*0.8){
AliExternalTrackParam paramIn;
AliExternalTrackParam paramOut;
}
-void AliTPCtrackerMI::DeleteSeeds()
+Int_t AliTPCtrackerMI::PostProcess(AliESDEvent *event)
{
//
- //delete Seeds
+ // Post process events
+ //
+ if (!event) return 0;
- 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);
+ //
+ // Set TPC event status
+ //
+
+ // event affected by HV dip
+ // reset TPC status
+ if(IsTPCHVDipEvent(event)) {
+ event->ResetDetectorStatus(AliDAQ::kTPC);
}
- delete fSeeds;
+
+ //printf("Status %d \n", event->IsDetectorOn(AliDAQ::kTPC));
+
+ return 0;
+}
+
+ void AliTPCtrackerMI::DeleteSeeds()
+{
+ //
+ fSeeds->Clear();
+ ResetSeedsPool();
+ delete fSeeds;
fSeeds =0;
}
-void AliTPCtrackerMI::ReadSeeds(AliESDEvent *const event, Int_t direction)
+void AliTPCtrackerMI::ReadSeeds(const AliESDEvent *const event, Int_t direction)
{
//
//read seeds from the event
AliTPCtrack t(*esd);
t.SetNumberOfClusters(0);
// AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha());
- AliTPCseed *seed = new AliTPCseed(t/*,t.GetAlpha()*/);
+ 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);
- // delete seed;
+ // MarkSeedFree( seed );
// continue;
//}
if ( direction ==2 &&(status & AliESDtrack::kTRDrefit) > 0 ) {
// rotate to the local coordinate system
//
fSectors=fInnerSec; fN=fkNIS;
- Double_t alpha=seed->GetAlpha() - fSectors->GetAlphaShift();
+ Double_t alpha=seed->GetAlpha();
if (alpha > 2.*TMath::Pi()) alpha -= 2.*TMath::Pi();
if (alpha < 0. ) alpha += 2.*TMath::Pi();
- Int_t ns=Int_t(alpha/fSectors->GetAlpha())%fN;
+ Int_t ns=Int_t(alpha/fSectors->GetAlpha()+0.0001)%fN;
alpha =ns*fSectors->GetAlpha() + fSectors->GetAlphaShift();
+ alpha-=seed->GetAlpha();
if (alpha<-TMath::Pi()) alpha += 2*TMath::Pi();
if (alpha>=TMath::Pi()) alpha -= 2*TMath::Pi();
- alpha-=seed->GetAlpha();
- if (!seed->Rotate(alpha)) {
- delete seed;
- continue;
+ if (TMath::Abs(alpha) > 0.001) { // This should not happen normally
+ AliWarning(Form("Rotating track over %f",alpha));
+ if (!seed->Rotate(alpha)) {
+ MarkSeedFree( seed );
+ continue;
+ }
}
seed->SetESD(esd);
// sign clusters
if (esd->GetKinkIndex(0)<=0){
for (Int_t irow=0;irow<160;irow++){
Int_t index = seed->GetClusterIndex2(irow);
- if (index>0){
+ if (index >= 0){
//
AliTPCclusterMI * cl = GetClusterMI(index);
seed->SetClusterPointer(irow,cl);
Double_t x[5], c[15];
// Int_t di = i1-i2;
//
- AliTPCseed * seed = new AliTPCseed();
+ 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);
- seed->~AliTPCseed(); // this does not set the pointer to 0...
- AliTPCseed *track=new(seed) AliTPCseed(x1, ns*alpha+shift, x, c, index);
-
+ 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){
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree(seed); seed = 0;
continue;
}
//}
if (track->GetNumberOfClusters()<(i1-i2)*0.5 ||
track->GetNumberOfClusters() < track->GetNFoundable()*0.6 ||
track->GetNShared()>0.4*track->GetNumberOfClusters() ) {
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree(seed); seed = 0;
continue;
}
nout1++;
track2->SetBConstrain(kFALSE);
track2->SetSeedType(1);
arr->AddLast(track2);
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree( seed ); seed = 0;
continue;
}
else{
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree( seed ); seed = 0;
continue;
}
}
track->SetSeedType(0);
- arr->AddLast(track);
- seed = new AliTPCseed;
+ arr->AddLast(track); // note, track is seed, don't free the 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);
}
- delete seed;
+ if (seed) MarkSeedFree( seed );
}
Double_t x[5], c[15];
//
// make temporary seed
- AliTPCseed * seed = new AliTPCseed;
+ AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
Double_t alpha=fOuterSec->GetAlpha(), shift=fOuterSec->GetAlphaShift();
// Double_t cs=cos(alpha), sn=sin(alpha);
//
y3 = kcl->GetY();
// apply angular cuts
if (TMath::Abs(y1-y3)>dymax) continue;
- x3 = x3;
+ //x3 = x3;
z3 = kcl->GetZ();
if (TMath::Abs(z1-z3)>dzmax) continue;
//
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
index=kr1.GetIndex(is);
- seed->~AliTPCseed();
- AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index);
+ 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){
- seed->Reset();
- seed->~AliTPCseed();
+ 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 ) {
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree( seed ); seed = 0;
continue;
}
FollowProlongation(*track2, i2,1);
track2->SetBConstrain(kFALSE);
track2->SetSeedType(4);
- arr->AddLast(track2);
- seed->Reset();
- seed->~AliTPCseed();
+ arr->AddLast(track2);
+ 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);
}
- delete seed;
+ if (seed) MarkSeedFree(seed);
}
AliTPCpolyTrack polytrack;
Int_t nclusters=fSectors[sec][row0];
- AliTPCseed * seed = new AliTPCseed;
+ AliTPCseed * seed = new( NextFreeSeed() ) AliTPCseed;
+ seed->SetPoolID(fLastSeedID);
Int_t sumused=0;
Int_t cused=0;
UInt_t index=0;
//kr0.GetIndex(is);
- seed->~AliTPCseed();
- AliTPCseed *track=new(seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
+ 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()) {
- //delete track;
- seed->Reset();
- seed->~AliTPCseed();
+ MarkSeedFree( seed ); seed = 0;
}
else {
- arr->AddLast(track);
- seed = new AliTPCseed;
+ arr->AddLast(track); // track IS seed, don't free 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);
}
- delete seed;
+ if (seed) MarkSeedFree( seed );
}
if ( (index<p0) || x0[0]<0 ){
if (trpoint->GetX()>1){
clindex = track->GetClusterIndex2(i);
- if (clindex>0){
+ if (clindex >= 0){
x0[0] = trpoint->GetX();
x0[1] = trpoint->GetY();
x0[2] = trpoint->GetZ();
if ( (index<p1) &&(trpoint->GetX()>1)){
clindex = track->GetClusterIndex2(i);
- if (clindex>0){
+ if (clindex >= 0){
x1[0] = trpoint->GetX();
x1[1] = trpoint->GetY();
x1[2] = trpoint->GetZ();
}
if ( (index<p2) &&(trpoint->GetX()>1)){
clindex = track->GetClusterIndex2(i);
- if (clindex>0){
+ if (clindex >= 0){
x2[0] = trpoint->GetX();
x2[1] = trpoint->GetY();
x2[2] = trpoint->GetZ();
c[14]=f40*sy1*f40+f42*sy2*f42+f43*sy3*f43;
// Int_t row1 = fSectors->GetRowNumber(x2[0]);
- AliTPCseed *seed=new AliTPCseed(x2[0], sec2*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ 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 AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ 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 AliTPCseed(xyz[2][0], sec[2]*fSectors->GetAlpha()+fSectors->GetAlphaShift(), x, c, 0);
+ 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++){
//
//
//
- delete array->RemoveAt(index1);
+ MarkSeedFree( array->RemoveAt(index1) );
}
}
}
}
-
-
-
void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
{
//
// find kinks
//
//
+ // 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
TObjArray *kinks= new TObjArray(10000);
// TObjArray *v0s= new TObjArray(10000);
}
else{
delete kinks->RemoveAt(i);
- if (seed0) delete seed0;
- if (seed1) delete seed1;
+ 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) delete seed0;
- if (seed1) delete seed1;
+ if (seed0) MarkSeedFree( seed0 );
+ if (seed1) MarkSeedFree( seed1 );
continue;
}
//
- delete seed0;
- delete seed1;
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
}
//
if (kinkl) quality[i] = 160*((0.1+kinkl->GetDistance())*(2.-kinkl->GetTPCDensityFactor()))/(sumn+40.); //the longest -clossest will win
}
for (Int_t i=row0;i<158;i++){
- if (daughter0.GetClusterIndex(i)>0 && daughter0.GetClusterIndex(i)>0){
+ //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)){
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
if (track0->GetKinkIndex(0)!=0) continue;
- if (shared[i]) delete array->RemoveAt(i);
+ if (shared[i]) MarkSeedFree( array->RemoveAt(i) );
}
//
}
}
if (Float_t(ishared+1)/Float_t(all+1)>0.5) {
- delete array->RemoveAt(i);
+ MarkSeedFree( array->RemoveAt(i) );
continue;
}
//
mother.SetKinkIndex(0,-(index+1));
daughter.SetKinkIndex(0,index+1);
if (mother.GetNumberOfClusters()>50) {
- delete array->RemoveAt(i);
- array->AddAt(new AliTPCseed(mother),i);
+ MarkSeedFree( array->RemoveAt(i) );
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
+ array->AddAt(mtc,i);
}
else{
- array->AddLast(new AliTPCseed(mother));
+ AliTPCseed* mtc = new( NextFreeSeed() ) AliTPCseed(mother);
+ mtc->SetPoolID(fLastSeedID);
+ array->AddLast(mtc);
}
- array->AddLast(new AliTPCseed(daughter));
+ 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);
}
}
-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);
+ 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);
+
+ 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);
}
seed1->Reset(kTRUE);
last = seed1->GetLastPoint();
//
- AliTPCseed *seed0 = new AliTPCseed(*seed);
+ AliTPCseed *seed0 = new( NextFreeSeed() ) AliTPCseed(*seed);
+ seed0->SetPoolID(fLastSeedID);
seed0->Reset(kFALSE);
seed0->Reset();
//
//
}
}
- delete seed0;
- delete seed1;
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
if (index<0) return 0;
//
Int_t row0 = GetRowNumber(kinks[index].GetR()); //row 0 estimate
- seed0 = new AliTPCseed(param0[index]);
- seed1 = new AliTPCseed(param1[index]);
+ 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){
- delete seed0;
- delete seed1;
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
return 0;
}
"\n";
}
if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(0)){
- delete seed0;
- delete seed1;
+ MarkSeedFree( seed0 );
+ MarkSeedFree( seed1 );
return 0;
}
if ( chi2P2+chi2P3<AliTPCReconstructor::GetRecoParam()->GetKinkAngleCutChi2(1)){
mother=*seed;
}
- delete seed0;
- delete 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);
- fSeeds->AddLast(new AliTPCseed(*seed/*,seed->GetAlpha()*/));
+ AliTPCseed* sdc = new( NextFreeSeed() ) AliTPCseed(*seed/*,seed->GetAlpha()*/);
+ sdc->SetPoolID(fLastSeedID);
+ fSeeds->AddLast(sdc);
}
- delete seed;
+ delete seed; // RS: this seed is not from the pool, delete it !!!
delete seedTree;
savedir->cd();
return 0;
Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *const esd)
{
//
+ // clusters to tracks
if (fSeeds) DeleteSeeds();
- fEvent = esd;
+ else ResetSeedsPool();
+ fEvent = esd;
+
+ AliTPCTransform *transform = AliTPCcalibDB::Instance()->GetTransform() ;
+ transform->SetCurrentTimeStamp( esd->GetTimeStamp());
+ transform->SetCurrentRun(esd->GetRunNumber());
+
Clusters2Tracks();
if (!fSeeds) return 1;
FillESD(fSeeds);
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<20) {
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
CookLabel(pt,0.1);
if (pt->GetRemoval()==10) {
if (pt->GetDensityFirst(20)>0.8 || pt->GetDensityFirst(30)>0.8 || pt->GetDensityFirst(40)>0.7)
- pt->Desactivate(10); // make track again active
+ pt->Desactivate(10); // make track again active // MvL: should be 0 ?
else{
pt->Desactivate(20);
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
}
}
}
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
CookLabel(pt,0.1); //For comparison only
pt->SetLab2(i);
}
else
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
}
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
t.SetUniqueID(i);
pt->SetLab2(i);
}
else
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
//AliTPCseed * seed1 = ReSeed(pt,0.05,0.5,1);
//if (seed1){
// FollowProlongation(*seed1,0);
fIteration = 2;
PrepareForProlongation(fSeeds,5.);
- PropagateForward2(fSeeds);
+ PropagateForard2(fSeeds);
printf("Time for FORWARD propagation: \t");timer.Print();timer.Start();
// RemoveUsed(fSeeds,0.7,0.7,6);
if (!pt) continue;
Int_t nc=t.GetNumberOfClusters();
if (nc<15) {
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
continue;
}
t.CookdEdx(0.02,0.6);
cerr<<found++<<'\r';
}
else
- delete fSeeds->RemoveAt(i);
+ MarkSeedFree( fSeeds->RemoveAt(i) );
pt->fLab2 = i;
}
*/
//
//
//tracking routine
- TObjArray * arr = new TObjArray;
+ static TObjArray arrTracks;
+ TObjArray * arr = &arrTracks;
//
fSectors = fOuterSec;
TStopwatch timer;
TObjArray * AliTPCtrackerMI::Tracking()
{
- //
+ // tracking
//
if (AliTPCReconstructor::GetRecoParam()->GetSpecialSeeding()) return TrackingSpecial();
TStopwatch timer;
}
-void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *&arr2) const
+void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *&arr2)
{
//
//sum tracks to common container
//remove suspicious tracks
+ // RS: Attention: supplied tracks come in the static array, don't delete them
Int_t nseed = arr2->GetEntriesFast();
for (Int_t i=0;i<nseed;i++){
AliTPCseed *pt=(AliTPCseed*)arr2->UncheckedAt(i);
// remove tracks with too big curvature
//
if (TMath::Abs(pt->GetC())>AliTPCReconstructor::GetRecoParam()->GetMaxC()){
- delete arr2->RemoveAt(i);
+ MarkSeedFree( arr2->RemoveAt(i) );
continue;
}
// REMOVE VERY SHORT TRACKS
if (pt->GetNumberOfClusters()<20){
- delete arr2->RemoveAt(i);
+ MarkSeedFree( arr2->RemoveAt(i) );
continue;
}// patch 28 fev06
// NORMAL ACTIVE TRACK
}
//remove not usable tracks
if (pt->GetRemoval()!=10){
- delete 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{
- delete arr2->RemoveAt(i);
+ MarkSeedFree( arr2->RemoveAt(i) );
}
}
}
- delete arr2; arr2 = 0;
+ // delete arr2; arr2 = 0; // RS: this is static array, don't delete it
}
}
}
-void AliTPCtrackerMI::PrepareForBackProlongation(TObjArray *const arr,Float_t fac) const
+void AliTPCtrackerMI::PrepareForBackProlongation(const TObjArray *const arr,Float_t fac) const
{
//
//
Float_t angle2 = pt->GetAlpha();
if (TMath::Abs(angle1-angle2)>0.001){
- pt->Rotate(angle1-angle2);
+ if (!pt->Rotate(angle1-angle2)) return;
//angle2 = pt->GetAlpha();
//pt->fRelativeSector = pt->GetAlpha()/fInnerSec->GetAlpha();
//if (pt->GetAlpha()<0)
}
-Int_t AliTPCtrackerMI::PropagateBack(TObjArray *const arr)
+Int_t AliTPCtrackerMI::PropagateBack(const TObjArray *const arr)
{
//
// make back propagation
fSectors = fInnerSec;
//FollowBackProlongation(*pt,fInnerSec->GetNRows()-1);
//fSectors = fOuterSec;
- FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1);
+ FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1);
//if (pt->GetNumberOfClusters()<(pt->fEsd->GetTPCclusters(0)) ){
// Error("PropagateBack","Not prolonged track %d",pt->GetLabel());
// FollowBackProlongation(*pt2,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1);
AliESDkink * kink = fEvent->GetKink(pt->GetKinkIndex(0)-1);
pt->SetFirstPoint(kink->GetTPCRow0());
fSectors = fInnerSec;
- FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1);
+ FollowBackProlongation(*pt,fInnerSec->GetNRows()+fOuterSec->GetNRows()-1,1);
}
CookLabel(pt,0.3);
}
}
-Int_t AliTPCtrackerMI::PropagateForward2(TObjArray *const arr)
+Int_t AliTPCtrackerMI::PropagateForward2(const TObjArray *const arr)
{
//
// make forward propagation
for (Int_t i=0;i<nseed;i++){
AliTPCseed *pt = (AliTPCseed*)arr->UncheckedAt(i);
if (pt) {
- FollowProlongation(*pt,0);
+ FollowProlongation(*pt,0,1,1);
CookLabel(pt,0.3);
}
}
- return 0;
+ return 0;
}
void AliTPCtrackerMI::GetShape(AliTPCseed * seed, Int_t row)
{
- //
+ // gets cluster shape
//
AliTPCClusterParam * clparam = AliTPCcalibDB::Instance()->GetClusterParam();
Float_t zdrift = TMath::Abs((fkParam->GetZLength(0)-TMath::Abs(seed->GetZ())));
}
}
noc = current;
- if (noc<5) return -1;
+ //if (noc<5) return -1;
Int_t lab=123456789;
for (i=0; i<noc; i++) {
AliTPCclusterMI *c=clusters[i];
-void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t)
+void AliTPCtrackerMI::MakeESDBitmaps(AliTPCseed *t, AliESDtrack *esd)
{
//-----------------------------------------------------------------------
// Fill the cluster and sharing bitmaps of the track
AliTPCTrackerPoint *point;
AliTPCclusterMI *cluster;
+ Int_t nclsf = 0;
+ TBits clusterMap(159);
+ TBits sharedMap(159);
+ TBits fitMap(159);
for (int iter=firstpoint; iter<lastpoint; iter++) {
// Change to cluster pointers to see if we have a cluster at given padrow
+
cluster = t->GetClusterPointer(iter);
if (cluster) {
- t->SetClusterMapBit(iter, kTRUE);
+ clusterMap.SetBitNumber(iter, kTRUE);
point = t->GetTrackPoint(iter);
if (point->IsShared())
- t->SetSharedMapBit(iter,kTRUE);
- else
- t->SetSharedMapBit(iter, kFALSE);
+ sharedMap.SetBitNumber(iter,kTRUE);
}
- else {
- t->SetClusterMapBit(iter, kFALSE);
- t->SetSharedMapBit(iter, kFALSE);
+ if (t->GetClusterIndex(iter) >= 0 && (t->GetClusterIndex(iter) & 0x8000) == 0) {
+ fitMap.SetBitNumber(iter, kTRUE);
+ nclsf++;
}
}
+ esd->SetTPCClusterMap(clusterMap);
+ esd->SetTPCSharedMap(sharedMap);
+ esd->SetTPCFitMap(fitMap);
+ if (nclsf != t->GetNumberOfClusters())
+ AliWarning(Form("Inconsistency between ncls %d and indices %d (found %d)",t->GetNumberOfClusters(),nclsf,esd->GetTPCClusterMap().CountBits()));
}
Bool_t AliTPCtrackerMI::IsFindable(AliTPCseed & track){
void AliTPCtrackerMI::AddCovariance(AliTPCseed * seed){
//
- // Adding systematic error
- // !!!! the systematic error for element 4 is in 1/cm not in pt
+ // Adding systematic error estimate to the covariance matrix
+ // !!!! 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
+ if (!AliTPCReconstructor::GetRecoParam()->GetUseSystematicCorrelation()) return AddCovarianceAdd(seed);
+ //
+ Double_t *covarS= (Double_t*)seed->GetCovariance();
+ Double_t factor[5]={1,1,1,1,1};
+ 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] +param[4]*param[4])/covarS[14]));
+ //
+ factor[0]=factor[2];
+ factor[4]=factor[2];
+ // 0
+ // 1 2
+ // 3 4 5
+ // 6 7 8 9
+ // 10 11 12 13 14
+ for (Int_t i=0; i<5; i++){
+ for (Int_t j=i; j<5; j++){
+ Int_t index=seed->GetIndex(i,j);
+ covarS[index]*=factor[i]*factor[j];
+ }
+ }
+}
+
+
+void AliTPCtrackerMI::AddCovarianceAdd(AliTPCseed * seed){
+ //
+ // 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();
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...
+}