#include <TObjArray.h>
#include <TTree.h>
#include "AliLog.h"
-
#include "AliComplexCluster.h"
-#include "AliESD.h"
+#include "AliESDEvent.h"
+#include "AliESDtrack.h"
+#include "AliESDVertex.h"
#include "AliKink.h"
#include "AliV0.h"
#include "AliHelix.h"
#include "AliAlignObj.h"
#include "AliTrackPointArray.h"
+//#include "AliTPCTransform.h"
+
//
ClassImp(AliTPCtrackerMI)
}
-void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESD * event)
+void AliTPCtrackerMI::SetIO(TTree * input, TTree * output, AliESDEvent * event)
{
// set input
return 1.;
}
Float_t snoise2;
- Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ()));
+ Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
Int_t ctype = cl->GetType();
Float_t padlength= GetPadPitchLength(seed->GetRow());
Double_t angle2 = seed->GetSnp()*seed->GetSnp();
return 1.;
}
Float_t snoise2;
- Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ()));
+ Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
Int_t ctype = cl->GetType();
Float_t padlength= GetPadPitchLength(seed->GetRow());
//
//return 0.1;
Float_t snoise2;
- Float_t z = TMath::Abs(fParam->GetZLength()-TMath::Abs(seed->GetZ()));
+ Float_t z = TMath::Abs(fParam->GetZLength(0)-TMath::Abs(seed->GetZ()));
//
Float_t rsigmaz = cl->GetSigmaZ2()/(seed->fCurrentSigmaZ2);
Int_t ctype = cl->GetType();
}
void AliTPCtrackerMI::Transform(AliTPCclusterMI * cluster){
+ //
+ //
+ //
+// AliTPCTransform trafo;
+
+// Double_t x[3]={cluster->GetX(),cluster->GetY(),cluster->GetZ()};
+// Int_t i[1]={cluster->GetDetector()};
+
+// trafo.Transform(x,i,0,1);
+
+// cluster->SetX(x[0]);
+// cluster->SetY(x[1]);
+// cluster->SetZ(x[2]);
+
+// return;
+
+ // The old stuff:
+
//
//
//
}
else
{
- if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fParam->GetZLength() && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker()))
+ if (TMath::Abs(z)<(AliTPCReconstructor::GetCtgRange()*x+10) && TMath::Abs(z)<fParam->GetZLength(0) && (TMath::Abs(t.GetSnp())<AliTPCReconstructor::GetMaxSnpTracker()))
t.SetNFoundable(t.GetNFoundable()+1);
else
return 0;
cov[4] = 0.;
cov[5] = sigmaZ2;
p.SetXYZ(x,y,xyz[2],cov);
- AliAlignObj::ELayerID iLayer;
+ AliGeomManager::ELayerID iLayer;
Int_t idet;
if (sector < fParam->GetNInnerSector()) {
- iLayer = AliAlignObj::kTPC1;
+ iLayer = AliGeomManager::kTPC1;
idet = sector;
}
else {
- iLayer = AliAlignObj::kTPC2;
+ iLayer = AliGeomManager::kTPC2;
idet = sector - fParam->GetNInnerSector();
}
- UShort_t volid = AliAlignObj::LayerToVolUID(iLayer,idet);
+ UShort_t volid = AliGeomManager::LayerToVolUID(iLayer,idet);
p.SetVolumeID(volid);
return kTRUE;
}
{
//
//
- if (TMath::Abs(s1->GetC()-s2->GetC())>0.004) return;
- if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>0.6) return;
-
- Float_t dz2 =(s1->GetZ() - s2->GetZ());
- dz2*=dz2;
- Float_t dy2 =(s1->GetY() - s2->GetY());
- dy2*=dy2;
- Float_t distance = dz2+dy2;
- if (distance>325.) return ; // if there are far away - not overlap - to reduce combinatorics
+ Float_t thetaCut = 0.2;//+10.*TMath::Sqrt(s1->GetSigmaTglZ()+ s2->GetSigmaTglZ());
+ if (TMath::Abs(s1->GetTgl()-s2->GetTgl())>thetaCut) return;
+ Float_t minCl = TMath::Min(s1->GetNumberOfClusters(),s2->GetNumberOfClusters());
+ Int_t cutN0 = TMath::Max(5,TMath::Nint(0.1*minCl));
//
Int_t sumshared=0;
//
- Int_t firstpoint = TMath::Max(s1->GetFirstPoint(),s2->GetFirstPoint());
- Int_t lastpoint = TMath::Min(s1->GetLastPoint(),s2->GetLastPoint());
+ //Int_t firstpoint = TMath::Max(s1->GetFirstPoint(),s2->GetFirstPoint());
+ //Int_t lastpoint = TMath::Min(s1->GetLastPoint(),s2->GetLastPoint());
+ Int_t firstpoint = 0;
+ Int_t lastpoint = 160;
//
- if (firstpoint>=lastpoint-5) return;;
+ // if (firstpoint>=lastpoint-5) return;;
for (Int_t i=firstpoint;i<lastpoint;i++){
// 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>4){
+ if (sumshared>cutN0){
// sign clusters
//
for (Int_t i=firstpoint;i<lastpoint;i++){
}
}
//
- if (sumshared>10){
+ if (sumshared>cutN0){
for (Int_t i=0;i<4;i++){
if (s1->GetOverlapLabel(3*i)==0){
s1->SetOverlapLabel(3*i, s2->GetLabel());
}
}
}
-
}
void AliTPCtrackerMI::SignShared(TObjArray * arr)
meanchi = sumchi/sum;
//
sdensity = sumdens2/sum-mdensity*mdensity;
- sdensity = TMath::Sqrt(sdensity);
+ if (sdensity >= 0)
+ sdensity = TMath::Sqrt(sdensity);
+ else
+ sdensity = 0.1;
//
smeann = sumn2/sum-meann*meann;
- smeann = TMath::Sqrt(smeann);
+ if (smeann >= 0)
+ smeann = TMath::Sqrt(smeann);
+ else
+ smeann = 10;
//
smeanchi = sumchi2/sum - meanchi*meanchi;
- smeanchi = TMath::Sqrt(smeanchi);
+ if (smeanchi >= 0)
+ smeanchi = TMath::Sqrt(smeanchi);
+ else
+ smeanchi = 0.4;
}
}
-Int_t AliTPCtrackerMI::RefitInward(AliESD *event)
+Int_t AliTPCtrackerMI::RefitInward(AliESDEvent *event)
{
//
// back propagation of ESD tracks
fIteration=2;
//PrepareForProlongation(fSeeds,1);
PropagateForward2(fSeeds);
+ TObjArray arraySeed(fSeeds->GetEntries());
+ for (Int_t i=0;i<fSeeds->GetEntries();i++) {
+ arraySeed.AddAt(fSeeds->At(i),i);
+ }
+ SignShared(&arraySeed);
Int_t ntracks=0;
Int_t nseed = fSeeds->GetEntriesFast();
seed->PropagateTo(fParam->GetInnerRadiusLow());
seed->UpdatePoints();
+ MakeBitmaps(seed);
AliESDtrack *esd=event->GetTrack(i);
seed->CookdEdx(0.02,0.6);
CookLabel(seed,0.1); //For comparison only
+ esd->SetTPCClusterMap(seed->GetClusterMap());
+ esd->SetTPCSharedMap(seed->GetSharedMap());
//
if (AliTPCReconstructor::StreamLevel()>0 && seed!=0&&esd!=0) {
TTreeSRedirector &cstream = *fDebugStreamer;
}
-Int_t AliTPCtrackerMI::PropagateBack(AliESD *event)
+Int_t AliTPCtrackerMI::PropagateBack(AliESDEvent *event)
{
//
// back propagation of ESD tracks
fSeeds =0;
}
-void AliTPCtrackerMI::ReadSeeds(AliESD *event, Int_t direction)
+void AliTPCtrackerMI::ReadSeeds(AliESDEvent *event, Int_t direction)
{
//
//read seeds from the event
t.SetNumberOfClusters(0);
// AliTPCseed *seed = new AliTPCseed(t,t.GetAlpha());
AliTPCseed *seed = new AliTPCseed(t/*,t.GetAlpha()*/);
+ seed->SetUniqueID(esd->GetID());
for (Int_t ikink=0;ikink<3;ikink++) {
Int_t index = esd->GetKinkIndex(ikink);
seed->GetKinkIndexes()[ikink] = index;
Double_t x[5], c[15];
// Int_t di = i1-i2;
//
- AliTPCseed * seed = new AliTPCseed;
+ AliTPCseed * seed = new AliTPCseed();
Double_t alpha=fSectors->GetAlpha(), shift=fSectors->GetAlphaShift();
Double_t cs=cos(alpha), sn=sin(alpha);
//
// 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);
track->SetIsSeeding(kTRUE);
}
}
}
-
+
track->SetSeedType(0);
arr->AddLast(track);
seed = new AliTPCseed;
// if (!BuildSeed(kr1[is],kcl,0,x1,x2,x3,x,c)) continue;
UInt_t index=kr1.GetIndex(is);
+ seed->~AliTPCseed();
AliTPCseed *track=new(seed) AliTPCseed(x1, sec*alpha+shift, x, c, index);
track->SetIsSeeding(kTRUE);
UInt_t index=0;
//kr0.GetIndex(is);
- AliTPCseed *track=new (seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
+ seed->~AliTPCseed();
+ AliTPCseed *track=new(seed) AliTPCseed(x1,sec*alpha+shift,x,c,index);
track->SetIsSeeding(kTRUE);
Int_t rc=FollowProlongation(*track, i2);
if (constrain) track->SetBConstrain(1);
return seed;
}
-void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESD *esd)
+void AliTPCtrackerMI::FindKinks(TObjArray * array, AliESDEvent *esd)
{
//
// find kinks
if ( TMath::Abs(track1->GetTgl()+track0->GetTgl())>0.1) continue;
if (track0->GetBConstrain()&&track1->GetBConstrain()) continue;
if (TMath::Abs(1./track1->GetC())>200) continue;
- if (track1->Get1Pt()*track0->Get1Pt()>0) continue;
+ if (track1->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()&&TMath::Abs(track1->Get1Pt())<TMath::Abs(track0->Get1Pt())) continue; //returning - lower momenta
- if (track1->GetBConstrain()&&TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())) continue; //returning - lower momenta
+ 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;
if (sign){
circular[i0] = kTRUE;
circular[i1] = kTRUE;
- if (TMath::Abs(track0->Get1Pt())<TMath::Abs(track1->Get1Pt())){
+ if (track0->OneOverPt()<track1->OneOverPt()){
track0->SetCircular(track0->GetCircular()+1);
track1->SetCircular(track1->GetCircular()+2);
}
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;
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());
+ if (row0>60&&ktrack1->GetReference().GetX()>90.)new (¶md) AliExternalTrackParam(ktrack1->GetReference());
//
//
kink->SetMother(paramm);
if (RefitKink(*seed0,*seed1,*kink)) kink->SetStatus(1,9);
row0 = GetRowNumber(kink->GetR());
sumn = seed0->GetNumberOfClusters()+seed1->GetNumberOfClusters();
- new (&mothers[i]) AliTPCseed(*seed0);
- new (&daughters[i]) AliTPCseed(*seed1);
+ mothers[i] = *seed0;
+ daughters[i] = *seed1;
}
else{
delete kinks->RemoveAt(i);
//
if ( ktrack0->GetKinkIndex(0)==0 && ktrack1->GetKinkIndex(0)==0) { //best kink
if (mothers[indexes[i]].GetNumberOfClusters()>20 && daughters[indexes[i]].GetNumberOfClusters()>20 && (mothers[indexes[i]].GetNumberOfClusters()+daughters[indexes[i]].GetNumberOfClusters())>100){
- new (ktrack0) AliTPCseed(mothers[indexes[i]]);
- new (ktrack1) AliTPCseed(daughters[indexes[i]]);
+ *ktrack0 = mothers[indexes[i]];
+ *ktrack1 = daughters[indexes[i]];
}
}
//
for (Int_t i=0;i<nentries;i++){
AliTPCseed * track0 = (AliTPCseed*)array->At(i);
if (!track0) continue;
- if (track0->GetPt()<1.4) continue;
+ if (track0->Pt()<1.4) continue;
//remove double high momenta tracks - overlapped with kink candidates
Int_t shared=0;
Int_t all =0;
delete pkink;
continue; //too short tracks
}
- if (mother.GetPt()<1.4) {
+ if (mother.Pt()<1.4) {
delete pmother;
delete pdaughter;
delete pkink;
timer.Print();
}
-void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESD *esd)
+void AliTPCtrackerMI::FindV0s(TObjArray * array, AliESDEvent *esd)
{
//
// find V0s
"\n";
}
//
- if (track0->Get1Pt()<0) continue;
+ if (track0->GetSigned1Pt()<0) continue;
if (track0->GetKinkIndex(0)>0||isPrim[i]) continue; //daughter kink
//
if (TMath::Abs(helixes[i].GetHelix(4))<0.000000001) continue;
for (Int_t irow=0;irow<kNdiv;irow++){
FollowBackProlongation(mother, rows[irow]);
FollowProlongation(daughter,rows[kNdiv-1-irow]);
- new(¶m0[irow]) AliTPCseed(mother);
- new(¶m1[kNdiv-1-irow]) AliTPCseed(daughter);
+ param0[irow] = mother;
+ param1[kNdiv-1-irow] = daughter;
}
//
// define kinks
param0[index].Reset(kTRUE);
FollowProlongation(param0[index],0);
//
- new (&mother) AliTPCseed(param0[index]);
- new (&daughter) AliTPCseed(param1[index]); // daughter in vertex
+ mother = param0[index];
+ daughter = param1[index]; // daughter in vertex
//
kink.SetMother(mother);
kink.SetDaughter(daughter);
for (Int_t irow=0;irow<20;irow++){
FollowBackProlongation(*seed0, rows[irow]);
FollowProlongation(*seed1,rows[19-irow]);
- new(¶m0[irow]) AliTPCseed(*seed0);
- new(¶m1[19-irow]) AliTPCseed(*seed1);
+ param0[irow] = *seed0;
+ param1[19-irow] = *seed1;
}
//
// define kinks
seed1->ResetCovariance(10.);
FollowProlongation(*seed0,0);
FollowBackProlongation(*seed1,158);
- new (&mother) AliTPCseed(*seed0); // backup mother at position 0
+ mother = *seed0; // backup mother at position 0
seed0->Reset(kFALSE);
seed1->Reset(kFALSE);
seed0->ResetCovariance(10.);
for (Int_t irow=0;irow<20;irow++){
FollowBackProlongation(*seed0, rows[irow]);
FollowProlongation(*seed1,rows[19-irow]);
- new(¶m0[irow]) AliTPCseed(*seed0);
- new(¶m1[19-irow]) AliTPCseed(*seed1);
+ param0[irow] = *seed0;
+ param1[19-irow] = *seed1;
}
//
// define kinks
//
//
// new (&mother) AliTPCseed(param0[index]);
- new (&daughter) AliTPCseed(param1[index]);
+ daughter = param1[index];
daughter.SetLabel(kink.GetLabel(1));
param0[index].Reset(kTRUE);
FollowProlongation(param0[index],0);
- new (&mother) AliTPCseed(param0[index]);
+ mother = param0[index];
mother.SetLabel(kink.GetLabel(0));
delete seed0;
delete seed1;
return 0;
}
-Int_t AliTPCtrackerMI::Clusters2Tracks (AliESD *esd)
+Int_t AliTPCtrackerMI::Clusters2Tracks (AliESDEvent *esd)
{
//
if (fSeeds) DeleteSeeds();
fdensity = 2.;
cuts[0]=0.0080;
+ Int_t fLastSeedRowSec=AliTPCReconstructor::GetRecoParam()->GetLastSeedRowSec();
+
// find secondaries
- for (Int_t delta = 30; delta<90; delta+=10){
+ for (Int_t delta = 30; delta<fLastSeedRowSec; delta+=10){
//
cuts[0] = 0.3;
cuts[1] = 3.5;
}
-void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *arr2) const
+void AliTPCtrackerMI::SumTracks(TObjArray *arr1,TObjArray *&arr2) const
{
//
//sum tracks to common container
}
}
}
- delete arr2;
+ delete arr2; arr2 = 0;
}
{
//
//
- Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
+ Float_t sd2 = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
// Float_t padlength = fParam->GetPadPitchLength(seed->fSector);
Float_t padlength = GetPadPitchLength(row);
//
{
//
//
- Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
+ Float_t sd2 = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
Float_t padlength = fParam->GetPadPitchLength(seed->GetSector());
Float_t sres = (seed->GetSector() < fParam->GetNSector()/2) ? 0.2 :0.3;
Float_t angular = seed->GetSnp();
{
//
//
- Float_t sd2 = TMath::Abs((fParam->GetZLength()-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
+ Float_t sd2 = TMath::Abs((fParam->GetZLength(0)-TMath::Abs(seed->GetZ())))*fParam->GetDiffL()*fParam->GetDiffL();
Float_t padlength = fParam->GetPadPitchLength(seed->GetSector());
Float_t sres = fParam->GetZSigma();
Float_t angular = seed->GetTgl();
//--------------------------------------------------------------------
//This function "cooks" a track label. If label<0, this track is fake.
//--------------------------------------------------------------------
- AliTPCseed * t = (AliTPCseed*)tk;
+ AliTPCseed * t = dynamic_cast<AliTPCseed*>(tk);
+ if(!t){
+ printf("%s:%d wrong type \n",(char*)__FILE__,__LINE__);
+ return;
+ }
+
Int_t noc=t->GetNumberOfClusters();
if (noc<10){
//printf("\nnot founded prolongation\n\n\n");
fPadPitchWidth=par->GetInnerPadPitchWidth();
fPadPitchLength=par->GetInnerPadPitchLength();
fN=par->GetNRowLow();
+ if(fRow)delete [] fRow;fRow = 0;
fRow=new AliTPCRow[fN];
for (Int_t i=0; i<fN; i++) {
fRow[i].SetX(par->GetPadRowRadiiLow(i));
fPadPitchLength = par->GetOuter1PadPitchLength();
f1PadPitchLength = par->GetOuter1PadPitchLength();
f2PadPitchLength = par->GetOuter2PadPitchLength();
-
fN=par->GetNRowUp();
+ if(fRow)delete [] fRow;fRow = 0;
fRow=new AliTPCRow[fN];
for (Int_t i=0; i<fN; i++) {
fRow[i].SetX(par->GetPadRowRadiiUp(i));
AliTPCtrackerMI::AliTPCRow::~AliTPCRow(){
//
-
+ for (Int_t i = 0; i < fN1; i++)
+ fClusters1[i].~AliTPCclusterMI();
+ delete [] fClusters1;
+ for (Int_t i = 0; i < fN2; i++)
+ fClusters2[i].~AliTPCclusterMI();
+ delete [] fClusters2;
}
void AliTPCtrackerMI::AliTPCRow::ResetClusters() {
//
// reset clusters
+ // MvL: Need to call destructors for AliTPCclusterMI, to delete fInfo
+ for (Int_t i = 0; i < fN1; i++)
+ fClusters1[i].~AliTPCclusterMI();
+ delete [] fClusters1; fClusters1=0;
+ for (Int_t i = 0; i < fN2; i++)
+ fClusters2[i].~AliTPCclusterMI();
+ delete [] fClusters2; fClusters2=0;
+
fN = 0;
fN1 = 0;
fN2 = 0;
//delete[] fClusterArray;
- if (fClusters1) delete []fClusters1;
- if (fClusters2) delete []fClusters2;
+
//fClusterArray=0;
- fClusters1 = 0;
- fClusters2 = 0;
}
// }
+void AliTPCtrackerMI::MakeBitmaps(AliTPCseed *t)
+{
+ //-----------------------------------------------------------------------
+ // Fill the cluster and sharing bitmaps of the track
+ //-----------------------------------------------------------------------
+
+ Int_t firstpoint = 0;
+ Int_t lastpoint = 159;
+ AliTPCTrackerPoint *point;
+
+ for (int iter=firstpoint; iter<lastpoint; iter++) {
+ point = t->GetTrackPoint(iter);
+ if (point) {
+ t->SetClusterMapBit(iter, kTRUE);
+ if (point->IsShared())
+ t->SetSharedMapBit(iter,kTRUE);
+ else
+ t->SetSharedMapBit(iter, kFALSE);
+ }
+ else {
+ t->SetClusterMapBit(iter, kFALSE);
+ t->SetSharedMapBit(iter, kFALSE);
+ }
+ }
+}