--- /dev/null
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Author: The ALICE Off-line Project. *
+ * Contributors are mentioned in the code where appropriate. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+//-------------------------------------------------------------------------
+// Implementation of the ITS track class
+//
+// Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch
+// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
+//-------------------------------------------------------------------------
+
+#include <TMatrixD.h>
+
+#include <TMath.h>
+
+#include "AliCluster.h"
+#include "AliESDtrack.h"
+#include "AliITStrackMI.h"
+
+ClassImp(AliITStrackMI)
+
+const Int_t kWARN=5;
+
+//____________________________________________________________________________
+AliITStrackMI::AliITStrackMI():AliITStrackV2(),
+ fNUsed(0),
+ fNSkipped(0),
+ fNDeadZone(0),
+ fDeadZoneProbability(0),
+ fReconstructed(kFALSE),
+ fConstrain(kFALSE)
+{
+ for(Int_t i=0; i<kMaxLayer; i++) fClIndex[i]=-1;
+ for(Int_t i=0; i<6; i++) { fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
+ for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0; fChi2MIP[i]=0;}
+ fD[0]=0; fD[1]=0;
+ fExpQ=40;
+ fdEdxMismatch=0;
+ fChi22=0;
+}
+
+//____________________________________________________________________________
+AliITStrackMI::AliITStrackMI(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
+AliITStrackV2(t,c) {
+ //------------------------------------------------------------------
+ // Conversion ESD track -> ITS track.
+ // If c==kTRUE, create the ITS track out of the constrained params.
+ //------------------------------------------------------------------
+ fNUsed = 0;
+ fReconstructed = kFALSE;
+ fNSkipped =0;
+ fNDeadZone = 0;
+ fDeadZoneProbability = 0;
+ for(Int_t i=0; i<6; i++) {fClIndex[i]=-1; fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
+ for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0;fChi2MIP[i]=0;}
+ fD[0]=0; fD[1]=0;
+ fExpQ=40;
+ fConstrain = kFALSE;
+ fdEdxMismatch=0;
+ fChi22 =0;
+
+ //if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+
+}
+
+void AliITStrackMI::UpdateESDtrack(ULong_t flags) {
+ fESDtrack->UpdateTrackParams(this,flags);
+ if (flags == AliESDtrack::kITSin) fESDtrack->SetITSChi2MIP(fChi2MIP);
+}
+
+//____________________________________________________________________________
+AliITStrackMI::AliITStrackMI(const AliITStrackMI& t) : AliITStrackV2(t) {
+ //------------------------------------------------------------------
+ //Copy constructor
+ //------------------------------------------------------------------
+ fNUsed = t.fNUsed;
+ fReconstructed = t.fReconstructed;
+ fNSkipped = t.fNSkipped;
+ fNDeadZone = t.fNDeadZone;
+ fDeadZoneProbability = t.fDeadZoneProbability;
+ fLab = t.fLab;
+ fFakeRatio = t.fFakeRatio;
+ fdEdxMismatch = t.fdEdxMismatch;
+ fChi22 = t.fChi22;
+
+
+ fD[0]=t.fD[0]; fD[1]=t.fD[1];
+ fExpQ= t.fExpQ;
+ for(Int_t i=0; i<6; i++) {
+ fClIndex[i]= t.fClIndex[i]; fNy[i]=t.fNy[i]; fNz[i]=t.fNz[i]; fNormQ[i]=t.fNormQ[i]; fNormChi2[i] = t.fNormChi2[i];
+ }
+ for(Int_t i=0; i<12; i++) {fDy[i]=t.fDy[i]; fDz[i]=t.fDz[i];
+ fSigmaY[i]=t.fSigmaY[i]; fSigmaZ[i]=t.fSigmaZ[i];fChi2MIP[i]=t.fChi2MIP[i];}
+ fConstrain = t.fConstrain;
+ //memcpy(fDy,t.fDy,6*sizeof(Float_t));
+ //memcpy(fDz,t.fDz,6*sizeof(Float_t));
+ //memcpy(fSigmaY,t.fSigmaY,6*sizeof(Float_t));
+ //memcpy(fSigmaZ,t.fSigmaZ,6*sizeof(Float_t));
+ //memcpy(fChi2MIP,t.fChi2MIP,12*sizeof(Float_t));
+}
+
+//_____________________________________________________________________________
+Int_t AliITStrackMI::Compare(const TObject *o) const {
+ //-----------------------------------------------------------------
+ // This function compares tracks according to the their curvature
+ //-----------------------------------------------------------------
+ AliITStrackMI *t=(AliITStrackMI*)o;
+ //Double_t co=TMath::Abs(t->Get1Pt());
+ //Double_t c =TMath::Abs(Get1Pt());
+ Double_t co=t->GetSigmaY2()*t->GetSigmaZ2()*(0.5+TMath::Sqrt(0.5*t->fD[0]*t->fD[0]+t->fD[1]*t->fD[1]));
+ Double_t c =GetSigmaY2()*GetSigmaZ2()*(0.5+TMath::Sqrt(0.5*fD[0]*fD[0]+fD[1]*fD[1]));
+ if (c>co) return 1;
+ else if (c<co) return -1;
+ return 0;
+}
+
+
+Double_t AliITStrackMI::GetPredictedChi2MI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz) const
+{
+ //-----------------------------------------------------------------
+ // This function calculates a predicted chi2 increment.
+ //-----------------------------------------------------------------
+ Double_t r00=cerry*cerry, r01=0., r11=cerrz*cerrz;
+ r00+=fC00; r01+=fC10; r11+=fC11;
+ //
+ Double_t det=r00*r11 - r01*r01;
+ if (TMath::Abs(det) < 1.e-30) {
+ Int_t n=GetNumberOfClusters();
+ if (n>kWARN)
+ Warning("GetPredictedChi2","Singular matrix (%d) !\n",n);
+ return 1e10;
+ }
+ Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
+
+ Double_t dy=cy - fP0, dz=cz - fP1;
+
+ return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
+}
+
+//____________________________________________________________________________
+Int_t AliITStrackMI::CorrectForMaterial(Double_t d, Double_t x0) {
+ //------------------------------------------------------------------
+ //This function corrects the track parameters for crossed material
+ //------------------------------------------------------------------
+ // Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
+ Double_t p2=(1.+ fP3*fP3)/(Get1Pt()*Get1Pt());
+ Double_t et = p2 + GetMass()*GetMass();
+ Double_t beta2=p2/et;
+ et = sqrt(et);
+ d*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2));
+ //d*=TMath::Sqrt(1.+ fP3*fP3 +fP2*fP2/(1.- fP2*fP2));
+
+ //Multiple scattering******************
+ if (d!=0) {
+ Double_t theta2=14.1*14.1/(beta2*p2*1e6)*TMath::Abs(d);
+ //Double_t theta2=1.0259e-6*14*14/28/(beta2*p2)*TMath::Abs(d)*9.36*2.33;
+ fC22 += theta2*(1.- fP2*fP2)*(1. + fP3*fP3);
+ fC33 += theta2*(1. + fP3*fP3)*(1. + fP3*fP3);
+ fC43 += theta2*fP3*fP4*(1. + fP3*fP3);
+ fC44 += theta2*fP3*fP4*fP3*fP4;
+ }
+
+ //Energy losses************************
+ if (x0!=0.) {
+ d*=x0;
+ // Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
+ //Double_t dE=0;
+ Double_t dE = 0.265*0.153e-3*(39.2-55.6*beta2+28.7*beta2*beta2+27.41/beta2)*d;
+ /*
+ if (beta2/(1-beta2)>3.5*3.5){
+ dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
+ }
+ else{
+ dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
+ dE+=0.06e-3/(beta2*beta2)*d;
+ }
+ */
+ fP4*=(1.- et/p2*dE);
+ Double_t delta44 = (dE*fP4*et/p2);
+ delta44*=delta44;
+ fC44+= delta44/400.;
+ }
+
+ if (!Invariant()) return 0;
+
+ return 1;
+}
+
+//____________________________________________________________________________
+Int_t AliITStrackMI::UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t index) {
+ //------------------------------------------------------------------
+ //This function updates track parameters
+ //------------------------------------------------------------------
+ Double_t p0=fP0,p1=fP1,p2=fP2,p3=fP3,p4=fP4;
+ Double_t c00=fC00;
+ Double_t c10=fC10, c11=fC11;
+ Double_t c20=fC20, c21=fC21, c22=fC22;
+ Double_t c30=fC30, c31=fC31, c32=fC32, c33=fC33;
+ Double_t c40=fC40, c41=fC41, c42=fC42, c43=fC43, c44=fC44;
+
+
+ Double_t r00=cerry*cerry, r01=0., r11=cerrz*cerrz;
+ r00+=fC00; r01+=fC10; r11+=fC11;
+ Double_t det=r00*r11 - r01*r01;
+ Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
+
+
+ Double_t k00=fC00*r00+fC10*r01, k01=fC00*r01+fC10*r11;
+ Double_t k10=fC10*r00+fC11*r01, k11=fC10*r01+fC11*r11;
+ Double_t k20=fC20*r00+fC21*r01, k21=fC20*r01+fC21*r11;
+ Double_t k30=fC30*r00+fC31*r01, k31=fC30*r01+fC31*r11;
+ Double_t k40=fC40*r00+fC41*r01, k41=fC40*r01+fC41*r11;
+
+ Double_t dy=cy - fP0, dz=cz - fP1;
+ Int_t layer = (index & 0xf0000000) >> 28;
+ fDy[layer] = dy;
+ fDz[layer] = dz;
+ fSigmaY[layer] = TMath::Sqrt(cerry*cerry+fC00);
+ fSigmaZ[layer] = TMath::Sqrt(cerrz*cerrz+fC11);
+
+ Double_t sf=fP2 + k20*dy + k21*dz;
+
+ fP0 += k00*dy + k01*dz;
+ fP1 += k10*dy + k11*dz;
+ fP2 = sf;
+ fP3 += k30*dy + k31*dz;
+ fP4 += k40*dy + k41*dz;
+
+ Double_t c01=fC10, c02=fC20, c03=fC30, c04=fC40;
+ Double_t c12=fC21, c13=fC31, c14=fC41;
+
+ fC00-=k00*fC00+k01*fC10; fC10-=k00*c01+k01*fC11;
+ fC20-=k00*c02+k01*c12; fC30-=k00*c03+k01*c13;
+ fC40-=k00*c04+k01*c14;
+
+ fC11-=k10*c01+k11*fC11;
+ fC21-=k10*c02+k11*c12; fC31-=k10*c03+k11*c13;
+ fC41-=k10*c04+k11*c14;
+
+ fC22-=k20*c02+k21*c12; fC32-=k20*c03+k21*c13;
+ fC42-=k20*c04+k21*c14;
+
+ fC33-=k30*c03+k31*c13;
+ fC43-=k30*c04+k31*c14;
+
+ fC44-=k40*c04+k41*c14;
+
+ if (!Invariant()) {
+ fP0=p0; fP1=p1; fP2=p2; fP3=p3; fP4=p4;
+ fC00=c00;
+ fC10=c10; fC11=c11;
+ fC20=c20; fC21=c21; fC22=c22;
+ fC30=c30; fC31=c31; fC32=c32; fC33=c33;
+ fC40=c40; fC41=c41; fC42=c42; fC43=c43; fC44=c44;
+ return 0;
+ }
+
+ if (chi2<0) return 1;
+ Int_t n=GetNumberOfClusters();
+ fIndex[n]=index;
+ SetNumberOfClusters(n+1);
+ SetChi2(GetChi2()+chi2);
+
+ return 1;
+}
+
+Int_t AliITStrackMI::GetProlongationFast(Double_t alp, Double_t xk,Double_t &y, Double_t &z)
+{
+ //-----------------------------------------------------------------------------
+ //get fast prolongation
+ //-----------------------------------------------------------------------------
+ Double_t ca=TMath::Cos(alp-fAlpha), sa=TMath::Sin(alp-fAlpha);
+ Double_t cf=TMath::Sqrt(1.- fP2*fP2);
+ // **** rotation **********************
+ y= -fX*sa + fP0*ca;
+ // **** translation ******************
+ Double_t dx = xk- fX*ca - fP0*sa;
+ Double_t f1=fP2*ca - cf*sa, f2=f1 + fP4*dx;
+ if (TMath::Abs(f2) >= 0.9999) {
+ return 0;
+ }
+ Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
+ y += dx*(f1+f2)/(r1+r2);
+ z = fP1+dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
+ return 1;
+}
+
--- /dev/null
+#ifndef ALIITSTRACKMI_H
+#define ALIITSTRACKMI_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice */
+
+//-------------------------------------------------------------------------
+// ITS Track Class
+//
+// Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch
+// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
+//-------------------------------------------------------------------------
+
+
+/*****************************************************************************
+ * December 18, 2000 *
+ * Internal view of the ITS track parametrisation as well as the order of *
+ * track parameters are subject for possible changes ! *
+ * Use GetExternalParameters() and GetExternalCovariance() to access ITS *
+ * track information regardless of its internal representation. *
+ * This formation is now fixed in the following way: *
+ * external param0: local Y-coordinate of a track (cm) *
+ * external param1: local Z-coordinate of a track (cm) *
+ * external param2: local sine of the track momentum azimuthal angle *
+ * external param3: tangent of the track momentum dip angle *
+ * external param4: 1/pt (1/(GeV/c)) *
+ *****************************************************************************/
+
+#include <AliKalmanTrack.h>
+
+#include "AliITSrecoV2.h"
+#include "AliITStrackV2.h"
+
+class AliESDtrack;
+
+//_____________________________________________________________________________
+class AliITStrackMI : public AliITStrackV2 {
+ friend class AliITStrackerV2;
+ friend class AliITStrackerMI;
+public:
+ AliITStrackMI();
+ AliITStrackMI(AliESDtrack& t,Bool_t c=kFALSE) throw (const Char_t *);
+ AliITStrackMI(const AliITStrackMI& t);
+ Int_t GetProlongationFast(Double_t alpha, Double_t xr,Double_t &y, Double_t &z);
+ Int_t UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t i);
+ Int_t CorrectForMaterial(Double_t d, Double_t x0=21.82);
+
+ void UpdateESDtrack(ULong_t flags);
+
+ void SetReconstructed(Bool_t sr=kTRUE){fReconstructed = sr;}
+ Bool_t GetReconstructed() const {return fReconstructed;}
+ void SetChi2MIP(Int_t i,Float_t val){fChi2MIP[i]=val;}
+ Float_t GetChi2MIP(Int_t i) const {return fChi2MIP[i];}
+ void IncrementNSkipped(){fNSkipped++;} // increment by 1 the # of skipped cls
+ Float_t GetNSkipped() const {return fNSkipped;}
+ void IncrementNUsed(){fNUsed++;} // increment by 1 the # of shared clusters
+ Float_t GetNUsed() const {return fNUsed;}
+
+ Int_t Compare(const TObject *o) const;
+ Double_t GetCov33() const {return fC33;} // cov. matrix el. 3,3
+ Double_t GetCov44() const {return fC44;} // cov. matrix el. 4,4
+ Float_t GetDy(Int_t i) const {return fDy[i];}
+ Float_t GetDz(Int_t i) const {return fDz[i];}
+ Float_t GetSigmaY(Int_t i) const {return fSigmaY[i];}
+ Float_t GetSigmaZ(Int_t i) const {return fSigmaZ[i];}
+
+ Double_t GetPredictedChi2MI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz) const;
+
+protected:
+
+ Float_t fNUsed; // number of shared clusters
+ Float_t fNSkipped; // number of skipped clusters
+ Float_t fNDeadZone; // number of clusters in dead zone
+ Float_t fDeadZoneProbability; // probability to cross dead zone
+ Bool_t fReconstructed; // reconstructed - accepted flag
+ Float_t fChi2MIP[12]; // MIP chi squres
+
+ Float_t fDy[12]; //dy in layer
+ Float_t fDz[12]; //dz in layer
+ Float_t fSigmaY[12]; //sigma y
+ Float_t fSigmaZ[12]; //sigma z
+ Float_t fNy[6]; //expected size of cluster
+ Float_t fNz[6]; //expected size of cluster
+ Float_t fD[2]; //distance to the vertex
+ Float_t fNormQ[6]; // normalized Q
+ Float_t fExpQ; // expected Q
+ Float_t fNormChi2[6]; // normalized chi2
+ Float_t fChi22; // chi22
+ Float_t fdEdxMismatch;
+ Bool_t fConstrain; //indication of the vertex constrain
+ Int_t fClIndex[6]; //cluster Index
+
+ ClassDef(AliITStrackMI,1) //ITS reconstructed track
+};
+
+#endif
+
+
ClassImp(AliITStrackSA)
//_____________________________________
-AliITStrackSA:: AliITStrackSA() : AliITStrackV2(){
+AliITStrackSA:: AliITStrackSA() : AliITStrackMI(){
// Default constructor
SetNumberOfClusters(0);
SetNumberOfClustersSA(0);
//___________________________________________________
-AliITStrackSA::AliITStrackSA(const AliITStrackV2& t) :
-AliITStrackV2(t){
+AliITStrackSA::AliITStrackSA(const AliITStrackMI& t) :
+AliITStrackMI(t){
// Copy a V2 track into a SA track
SetNumberOfClustersSA(0);
ResetIndexSA();
}
//___________________________________________________
AliITStrackSA::AliITStrackSA(const AliITStrackSA& t) :
-AliITStrackV2(t){
+AliITStrackMI(t){
// Copy constructor
ResetIndexSA();
// //
////////////////////////////////////////////////////
-#include "AliITStrackV2.h"
+#include "AliITStrackMI.h"
-class AliITStrackSA : public AliITStrackV2 {
+class AliITStrackSA : public AliITStrackMI {
public:
AliITStrackSA();
- AliITStrackSA(const AliITStrackV2& t);
+ AliITStrackSA(const AliITStrackMI& t);
AliITStrackSA(const AliITStrackSA& t);
AliITStrackSA(Int_t layer, Int_t ladder, Int_t detector,
Double_t Ycoor, Double_t Zcoor, Double_t phi,
UInt_t fSain[fgkMaxNumberOfClusters]; // cluster index (SA)
Int_t fNSA; // number of clusters SA
- ClassDef(AliITStrackSA,1)
+ ClassDef(AliITStrackSA,2)
};
#endif
#include <TMath.h>
#include "AliCluster.h"
-#include "AliTPCtrack.h"
#include "AliESDtrack.h"
#include "AliITStrackV2.h"
fC42(0),
fC43(0),
fC44(0),
- fNUsed(0),
- fNSkipped(0),
- fNDeadZone(0),
- fDeadZoneProbability(0),
- fReconstructed(kFALSE),
- fConstrain(kFALSE),
fESDtrack(0)
{
- for(Int_t i=0; i<kMaxLayer; i++) {fIndex[i]=0;fClIndex[i]=-1;}
+ for(Int_t i=0; i<kMaxLayer; i++) fIndex[i]=0;
for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
- for(Int_t i=0; i<6; i++) { fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
- for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0; fChi2MIP[i]=0;}
- fD[0]=0; fD[1]=0;
- fExpQ=40;
- fdEdxMismatch=0;
- fChi22=0;
}
-//____________________________________________________________________________
-AliITStrackV2::AliITStrackV2(const AliTPCtrack& t) throw (const Char_t *) :
-AliKalmanTrack(t) {
- //------------------------------------------------------------------
- //Conversion TPC track -> ITS track
- //------------------------------------------------------------------
- SetChi2(0.);
- SetNumberOfClusters(0);
-
- fdEdx = t.GetdEdx();
- SetMass(t.GetMass());
-
- fAlpha = t.GetAlpha();
- if (fAlpha < -TMath::Pi()) fAlpha += 2*TMath::Pi();
- else if (fAlpha >= TMath::Pi()) fAlpha -= 2*TMath::Pi();
-
- //Conversion of the track parameters
- Double_t x,p[5]; t.GetExternalParameters(x,p);
- fX=x; x=GetConvConst();
- fP0=p[0];
- fP1=p[1];
- fP2=p[2];
- fP3=p[3];
- fP4=p[4]/x;
-
- //Conversion of the covariance matrix
- Double_t c[15]; t.GetExternalCovariance(c);
-
- fC00=c[0 ];
- fC10=c[1 ]; fC11=c[2 ];
- fC20=c[3 ]; fC21=c[4 ]; fC22=c[5 ];
- fC30=c[6 ]; fC31=c[7 ]; fC32=c[8 ]; fC33=c[9 ];
- fC40=c[10]/x; fC41=c[11]/x; fC42=c[12]/x; fC43=c[13]/x; fC44=c[14]/x/x;
-
- for(Int_t i=0; i<6; i++) { fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
- for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0; }
- fConstrain=kFALSE;
- //
- if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
-
-}
//____________________________________________________________________________
AliITStrackV2::AliITStrackV2(AliESDtrack& t,Bool_t c) throw (const Char_t *) :
SetIntegratedLength(t.GetIntegratedLength());
}
fESDtrack=&t;
- fNUsed = 0;
- fReconstructed = kFALSE;
- fNSkipped =0;
- fNDeadZone = 0;
- fDeadZoneProbability = 0;
- for(Int_t i=0; i<6; i++) {fClIndex[i]=-1; fNy[i]=0; fNz[i]=0; fNormQ[i]=0; fNormChi2[i]=1000;}
- for(Int_t i=0; i<12; i++) {fDy[i]=0; fDz[i]=0; fSigmaY[i]=0; fSigmaZ[i]=0;fChi2MIP[i]=0;}
- fD[0]=0; fD[1]=0;
- fExpQ=40;
- fConstrain = kFALSE;
- fdEdxMismatch=0;
- fChi22 =0;
-
- //if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
+ if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
}
-void AliITStrackV2::UpdateESDtrack(ULong_t flags) {
+void AliITStrackV2::UpdateESDtrack(ULong_t flags) const {
fESDtrack->UpdateTrackParams(this,flags);
- if (flags == AliESDtrack::kITSin) fESDtrack->SetITSChi2MIP(fChi2MIP);
}
-void AliITStrackV2::SetConstrainedESDtrack(Double_t chi2) {
+void AliITStrackV2::SetConstrainedESDtrack(Double_t chi2) const {
fESDtrack->SetConstrainedTrackParams(this,chi2);
}
if (i<4) fdEdxSample[i]=t.fdEdxSample[i];
}
fESDtrack=t.fESDtrack;
- fNUsed = t.fNUsed;
- fReconstructed = t.fReconstructed;
- fNSkipped = t.fNSkipped;
- fNDeadZone = t.fNDeadZone;
- fDeadZoneProbability = t.fDeadZoneProbability;
- fLab = t.fLab;
- fFakeRatio = t.fFakeRatio;
- fdEdxMismatch = t.fdEdxMismatch;
- fChi22 = t.fChi22;
-
-
- fD[0]=t.fD[0]; fD[1]=t.fD[1];
- fExpQ= t.fExpQ;
- for(Int_t i=0; i<6; i++) {
- fClIndex[i]= t.fClIndex[i]; fNy[i]=t.fNy[i]; fNz[i]=t.fNz[i]; fNormQ[i]=t.fNormQ[i]; fNormChi2[i] = t.fNormChi2[i];
- }
- for(Int_t i=0; i<12; i++) {fDy[i]=t.fDy[i]; fDz[i]=t.fDz[i];
- fSigmaY[i]=t.fSigmaY[i]; fSigmaZ[i]=t.fSigmaZ[i];fChi2MIP[i]=t.fChi2MIP[i];}
- fConstrain = t.fConstrain;
- //memcpy(fDy,t.fDy,6*sizeof(Float_t));
- //memcpy(fDz,t.fDz,6*sizeof(Float_t));
- //memcpy(fSigmaY,t.fSigmaY,6*sizeof(Float_t));
- //memcpy(fSigmaZ,t.fSigmaZ,6*sizeof(Float_t));
- //memcpy(fChi2MIP,t.fChi2MIP,12*sizeof(Float_t));
}
//_____________________________________________________________________________
AliITStrackV2 *t=(AliITStrackV2*)o;
//Double_t co=TMath::Abs(t->Get1Pt());
//Double_t c =TMath::Abs(Get1Pt());
- Double_t co=t->GetSigmaY2()*t->GetSigmaZ2()*(0.5+TMath::Sqrt(0.5*t->fD[0]*t->fD[0]+t->fD[1]*t->fD[1]));
- Double_t c =GetSigmaY2()*GetSigmaZ2()*(0.5+TMath::Sqrt(0.5*fD[0]*fD[0]+fD[1]*fD[1]));
+ Double_t co=t->GetSigmaY2()*t->GetSigmaZ2();
+ Double_t c =GetSigmaY2()*GetSigmaZ2();
if (c>co) return 1;
else if (c<co) return -1;
return 0;
return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
}
-Double_t AliITStrackV2::GetPredictedChi2MI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz) const
-{
- //-----------------------------------------------------------------
- // This function calculates a predicted chi2 increment.
- //-----------------------------------------------------------------
- Double_t r00=cerry*cerry, r01=0., r11=cerrz*cerrz;
- r00+=fC00; r01+=fC10; r11+=fC11;
- //
- Double_t det=r00*r11 - r01*r01;
- if (TMath::Abs(det) < 1.e-30) {
- Int_t n=GetNumberOfClusters();
- if (n>kWARN)
- Warning("GetPredictedChi2","Singular matrix (%d) !\n",n);
- return 1e10;
- }
- Double_t tmp=r00; r00=r11; r11=tmp; r01=-r01;
-
- Double_t dy=cy - fP0, dz=cz - fP1;
-
- return (dy*r00*dy + 2*r01*dy*dz + dz*r11*dz)/det;
-}
-
//____________________________________________________________________________
Int_t AliITStrackV2::CorrectForMaterial(Double_t d, Double_t x0) {
//------------------------------------------------------------------
//This function corrects the track parameters for crossed material
//------------------------------------------------------------------
- // Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
Double_t p2=(1.+ fP3*fP3)/(Get1Pt()*Get1Pt());
- Double_t et = p2 + GetMass()*GetMass();
- Double_t beta2=p2/et;
- et = sqrt(et);
+ Double_t beta2=p2/(p2 + GetMass()*GetMass());
d*=TMath::Sqrt((1.+ fP3*fP3)/(1.- fP2*fP2));
- //d*=TMath::Sqrt(1.+ fP3*fP3 +fP2*fP2/(1.- fP2*fP2));
//Multiple scattering******************
if (d!=0) {
//Energy losses************************
if (x0!=0.) {
d*=x0;
- // Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
- //Double_t dE=0;
- Double_t dE = 0.265*0.153e-3*(39.2-55.6*beta2+28.7*beta2*beta2+27.41/beta2)*d;
- /*
- if (beta2/(1-beta2)>3.5*3.5){
+ Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
+ if (beta2/(1-beta2)>3.5*3.5)
dE=0.153e-3/beta2*(log(3.5*5940)+0.5*log(beta2/(1-beta2)) - beta2)*d;
- }
- else{
- dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d;
- dE+=0.06e-3/(beta2*beta2)*d;
- }
- */
- fP4*=(1.- et/p2*dE);
- Double_t delta44 = (dE*fP4*et/p2);
- delta44*=delta44;
- fC44+= delta44/400.;
+
+ fP4*=(1.- TMath::Sqrt(p2+GetMass()*GetMass())/p2*dE);
}
if (!Invariant()) return 0;
Double_t k40=fC40*r00+fC41*r01, k41=fC40*r01+fC41*r11;
Double_t dy=c->GetY() - fP0, dz=c->GetZ() - fP1;
- Int_t layer = (index & 0xf0000000) >> 28;
- fDy[layer] = dy;
- fDz[layer] = dz;
- fSigmaY[layer] = TMath::Sqrt(c->GetSigmaY2()+fC00);
- fSigmaZ[layer] = TMath::Sqrt(c->GetSigmaZ2()+fC11);
-
Double_t sf=fP2 + k20*dy + k21*dz;
fP0 += k00*dy + k01*dz;
return 1;
}
-//____________________________________________________________________________
-Int_t AliITStrackV2::UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t index) {
- //------------------------------------------------------------------
- //This function updates track parameters
- //------------------------------------------------------------------
- Double_t p0=fP0,p1=fP1,p2=fP2,p3=fP3,p4=fP4;
- Double_t c00=fC00;
- Double_t c10=fC10, c11=fC11;
- Double_t c20=fC20, c21=fC21, c22=fC22;
- Double_t c30=fC30, c31=fC31, c32=fC32, c33=fC33;
- Double_t c40=fC40, c41=fC41, c42=fC42, c43=fC43, c44=fC44;
-
-
- Double_t r00=cerry*cerry, r01=0., r11=cerrz*cerrz;
- r00+=fC00; r01+=fC10; r11+=fC11;
- Double_t det=r00*r11 - r01*r01;
- Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
-
-
- Double_t k00=fC00*r00+fC10*r01, k01=fC00*r01+fC10*r11;
- Double_t k10=fC10*r00+fC11*r01, k11=fC10*r01+fC11*r11;
- Double_t k20=fC20*r00+fC21*r01, k21=fC20*r01+fC21*r11;
- Double_t k30=fC30*r00+fC31*r01, k31=fC30*r01+fC31*r11;
- Double_t k40=fC40*r00+fC41*r01, k41=fC40*r01+fC41*r11;
-
- Double_t dy=cy - fP0, dz=cz - fP1;
- Int_t layer = (index & 0xf0000000) >> 28;
- fDy[layer] = dy;
- fDz[layer] = dz;
- fSigmaY[layer] = TMath::Sqrt(cerry*cerry+fC00);
- fSigmaZ[layer] = TMath::Sqrt(cerrz*cerrz+fC11);
-
- Double_t sf=fP2 + k20*dy + k21*dz;
-
- fP0 += k00*dy + k01*dz;
- fP1 += k10*dy + k11*dz;
- fP2 = sf;
- fP3 += k30*dy + k31*dz;
- fP4 += k40*dy + k41*dz;
-
- Double_t c01=fC10, c02=fC20, c03=fC30, c04=fC40;
- Double_t c12=fC21, c13=fC31, c14=fC41;
-
- fC00-=k00*fC00+k01*fC10; fC10-=k00*c01+k01*fC11;
- fC20-=k00*c02+k01*c12; fC30-=k00*c03+k01*c13;
- fC40-=k00*c04+k01*c14;
-
- fC11-=k10*c01+k11*fC11;
- fC21-=k10*c02+k11*c12; fC31-=k10*c03+k11*c13;
- fC41-=k10*c04+k11*c14;
-
- fC22-=k20*c02+k21*c12; fC32-=k20*c03+k21*c13;
- fC42-=k20*c04+k21*c14;
-
- fC33-=k30*c03+k31*c13;
- fC43-=k30*c04+k31*c14;
-
- fC44-=k40*c04+k41*c14;
-
- if (!Invariant()) {
- fP0=p0; fP1=p1; fP2=p2; fP3=p3; fP4=p4;
- fC00=c00;
- fC10=c10; fC11=c11;
- fC20=c20; fC21=c21; fC22=c22;
- fC30=c30; fC31=c31; fC32=c32; fC33=c33;
- fC40=c40; fC41=c41; fC42=c42; fC43=c43; fC44=c44;
- return 0;
- }
-
- if (chi2<0) return 1;
- Int_t n=GetNumberOfClusters();
- fIndex[n]=index;
- SetNumberOfClusters(n+1);
- SetChi2(GetChi2()+chi2);
-
- return 1;
-}
-
Int_t AliITStrackV2::Invariant() const {
//------------------------------------------------------------------
// This function is for debugging purpose only
Ft(2,3)=ca + sf/cf*sa;
TMatrixD tmp(C,TMatrixD::kMult,Ft);
- T=new TMatrixD(F,TMatrixD::kMult,tmp);
-
-
+ T=new TMatrixD(F,TMatrixD::kMult,tmp);
}
// **** translation ******************
return 1;
}
-
-
-Int_t AliITStrackV2::GetProlongationFast(Double_t alp, Double_t xk,Double_t &y, Double_t &z)
-{
- //-----------------------------------------------------------------------------
- //get fast prolongation
- //-----------------------------------------------------------------------------
- Double_t ca=TMath::Cos(alp-fAlpha), sa=TMath::Sin(alp-fAlpha);
- Double_t cf=TMath::Sqrt(1.- fP2*fP2);
- // **** rotation **********************
- y= -fX*sa + fP0*ca;
- // **** translation ******************
- Double_t dx = xk- fX*ca - fP0*sa;
- Double_t f1=fP2*ca - cf*sa, f2=f1 + fP4*dx;
- if (TMath::Abs(f2) >= 0.9999) {
- return 0;
- }
- Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
- y += dx*(f1+f2)/(r1+r2);
- z = fP1+dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
- return 1;
-}
-
-
Double_t AliITStrackV2::GetD(Double_t x, Double_t y) const {
//------------------------------------------------------------------
// This function calculates the transverse impact parameter
return 1;
}
-/*
-Int_t AliITStrackV2::Improve(Double_t x0,Double_t yv,Double_t zv) {
- //------------------------------------------------------------------
- //This function improves angular track parameters
- //------------------------------------------------------------------
- Double_t dy=fP0-yv, dz=fP1-zv;
- Double_t r2=fX*fX+dy*dy;
- Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
- Double_t beta2=p2/(p2 + GetMass()*GetMass());
- x0*=TMath::Sqrt((1.+ GetTgl()*GetTgl())/(1.- GetSnp()*GetSnp()));
- //Double_t theta2=14.1*14.1/(beta2*p2*1e6)*x0;
- Double_t theta2=1.0259e-6*14*14/28/(beta2*p2)*x0*9.36*2.33;
-
- Double_t par=0.5*(fP4*fX + dy*TMath::Sqrt(4/r2-fP4*fP4));
- Double_t sigma2 = theta2*(1.- GetSnp()*GetSnp())*(1. + GetTgl()*GetTgl());
- sigma2 += fC00/r2*(1.- dy*dy/r2)*(1.- dy*dy/r2);
- sigma2 += kSigmaYV*kSigmaYV/r2;
- sigma2 += 0.25*fC44*fX*fX;
- Double_t eps2=sigma2/(fC22+sigma2), eps=TMath::Sqrt(eps2);
- if (10*r2*fC44<fC22) {
- fP2 = eps2*fP2 + (1-eps2)*par;
- fC22*=eps2; fC21*=eps; fC20*=eps; fC32*=eps; fC42*=eps;
- }
-
- par=0.5*fP4*dz/TMath::ASin(0.5*fP4*TMath::Sqrt(r2));
- sigma2=theta2;
- sigma2 += fC11/r2+fC00*dy*dy*dz*dz/(r2*r2*r2);
- sigma2 += kSigmaZV*kSigmaZV/r2;
- eps2=sigma2/(fC33+sigma2); eps=TMath::Sqrt(eps2);
- Double_t tgl=fP3;
- fP3 = eps2*fP3 + (1-eps2)*par;
- fC33*=eps2; fC32*=eps; fC31*=eps; fC30*=eps; fC43*=eps;
-
- eps=TMath::Sqrt((1+fP3*fP3)/(1+tgl*tgl));
- fP4*=eps;
- fC44*=eps*eps; fC43*=eps;fC42*=eps; fC41*=eps; fC40*=eps;
-
- if (!Invariant()) return 0;
- return 1;
-}
-*/
void AliITStrackV2::ResetCovariance() {
//------------------------------------------------------------------
//This function makes a track forget its history :)
#include "AliITSrecoV2.h"
class AliESDtrack;
-class AliTPCtrack;
//_____________________________________________________________________________
class AliITStrackV2 : public AliKalmanTrack {
- friend class AliITStrackerV2;
- friend class AliITStrackerMI;
public:
AliITStrackV2();
- AliITStrackV2(const AliTPCtrack& t) throw (const Char_t *);
AliITStrackV2(AliESDtrack& t,Bool_t c=kFALSE) throw (const Char_t *);
AliITStrackV2(const AliITStrackV2& t);
Int_t PropagateToVertex(Double_t d=0., Double_t x0=0.);
Int_t Propagate(Double_t alpha, Double_t xr);
- Int_t GetProlongationFast(Double_t alpha, Double_t xr,Double_t &y, Double_t &z);
- Int_t CorrectForMaterial(Double_t d, Double_t x0=21.82);
+ virtual Int_t CorrectForMaterial(Double_t d, Double_t x0=21.82);
Int_t PropagateTo(Double_t xr, Double_t d, Double_t x0=21.82);
Int_t Update(const AliCluster* cl,Double_t chi2,UInt_t i);
- Int_t UpdateMI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz, Double_t chi2,UInt_t i);
Int_t Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]);
void SetdEdx(Double_t dedx) {fdEdx=dedx;}
void SetSampledEdx(Float_t q, Int_t i);
void SetDetectorIndex(Int_t i) {SetLabel(i);}
void ResetCovariance();
void ResetClusters() { SetChi2(0.); SetNumberOfClusters(0); }
- void UpdateESDtrack(ULong_t flags);
- void SetConstrainedESDtrack(Double_t chi2);
- void SetReconstructed(Bool_t sr=kTRUE){fReconstructed = sr;}
+ void UpdateESDtrack(ULong_t flags) const;
+ void SetConstrainedESDtrack(Double_t chi2) const;
- Bool_t GetReconstructed() const {return fReconstructed;}
- void SetChi2MIP(Int_t i,Float_t val){fChi2MIP[i]=val;}
- Float_t GetChi2MIP(Int_t i) const {return fChi2MIP[i];}
- void IncrementNSkipped(){fNSkipped++;} // increment by 1 the # of skipped cls
- Float_t GetNSkipped() const {return fNSkipped;}
- void IncrementNUsed(){fNUsed++;} // increment by 1 the # of shared clusters
- Float_t GetNUsed() const {return fNUsed;}
AliESDtrack *GetESDtrack() const {return fESDtrack;}
- Double_t GetCov33() const {return fC33;} // cov. matrix el. 3,3
- Double_t GetCov44() const {return fC44;} // cov. matrix el. 4,4
- Float_t GetDy(Int_t i) const {return fDy[i];}
- Float_t GetDz(Int_t i) const {return fDz[i];}
- Float_t GetSigmaY(Int_t i) const {return fSigmaY[i];}
- Float_t GetSigmaZ(Int_t i) const {return fSigmaZ[i];}
-
-
Int_t GetDetectorIndex() const {return GetLabel();}
Double_t GetX() const {return fX;}
Int_t GetClusterIndex(Int_t i) const {return fIndex[i];}
Int_t GetGlobalXYZat(Double_t r,Double_t &x,Double_t &y,Double_t &z) const;
Double_t GetPredictedChi2(const AliCluster *cluster) const;
- Double_t GetPredictedChi2MI(Double_t cy, Double_t cz, Double_t cerry, Double_t cerrz) const;
- Int_t Invariant() const;
+ Int_t Invariant() const;
protected:
Double_t fX; // X-coordinate of this track (reference plane)
Double_t fC20, fC21, fC22; // of the
Double_t fC30, fC31, fC32, fC33; // track
Double_t fC40, fC41, fC42, fC43, fC44; // parameters
- Float_t fNUsed; // number of shared clusters
- Float_t fNSkipped; // number of skipped clusters
- Float_t fNDeadZone; // number of clusters in dead zone
- Float_t fDeadZoneProbability; // probability to cross dead zone
- Bool_t fReconstructed; // reconstructed - accepted flag
- Float_t fChi2MIP[12]; // MIP chi squres
+
UInt_t fIndex[kMaxLayer]; // indices of associated clusters
Float_t fdEdxSample[4]; // array of dE/dx samples b.b.
- Float_t fDy[12]; //dy in layer
- Float_t fDz[12]; //dz in layer
- Float_t fSigmaY[12]; //sigma y
- Float_t fSigmaZ[12]; //sigma z
- Float_t fNy[6]; //expected size of cluster
- Float_t fNz[6]; //expected size of cluster
- Float_t fD[2]; //distance to the vertex
- Float_t fNormQ[6]; // normalized Q
- Float_t fExpQ; // expected Q
- Float_t fNormChi2[6]; // normalized chi2
- Float_t fChi22; // chi22
- Float_t fdEdxMismatch;
- Bool_t fConstrain; //indication of the vertex constrain
- Int_t fClIndex[6]; //cluster Index
+
AliESDtrack *fESDtrack; //! pointer to the connected ESD track
- ClassDef(AliITStrackV2,3) //ITS reconstructed track
+ ClassDef(AliITStrackV2,4) //ITS reconstructed track
};
inline
//-------------------------------------------------------------------------
// Implementation of the ITS tracker class
-// It reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks
+// It reads AliITSclusterV2 clusters and creates AliITStrackMI tracks
// and fills with them the ESD
-// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
-// Marian Ivanov, CERN, Marian.Ivanov@cern.ch
+// Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch
// dEdx analysis by: Boris Batyunya, JINR, Boris.Batiounia@cern.ch
//
//-------------------------------------------------------------------------
#include "AliITSrecoV2.h"
#include <TTree.h>
#include "AliITSgeom.h"
-#include "AliTPCtrack.h"
#include "AliESD.h"
#include "AliITSclusterV2.h"
#include "AliITStrackerMI.h"
for (Int_t i=0; i<kMaxLayer; i++) fgLayers[i].ResetClusters();
}
-static Int_t CorrectForDeadZoneMaterial(AliITStrackV2 *t) {
+static Int_t CorrectForDeadZoneMaterial(AliITStrackMI *t) {
//--------------------------------------------------------------------
// Correction for the material between the TPC and the ITS
// (should it belong to the TPC code ?)
if (esd->GetStatus()&AliESDtrack::kTPCout) continue;
if (esd->GetStatus()&AliESDtrack::kITSin) continue;
- AliITStrackV2 *t=0;
+ AliITStrackMI *t=0;
try {
- t=new AliITStrackV2(*esd);
+ t=new AliITStrackMI(*esd);
} catch (const Char_t *msg) {
Warning("Clusters2Tracks",msg);
delete t;
for (Int_t i=0; i<nentr; i++) {
// cerr<<fPass<<" "<<i<<'\r';
fCurrentEsdTrack = i;
- AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
+ AliITStrackMI *t=(AliITStrackMI*)itsTracks.UncheckedAt(i);
if (t==0) continue; //this track has been already tracked
if (t->fReconstructed&&(t->fNUsed<1.5)) continue; //this track was already "succesfully" reconstructed
if ( (TMath::Abs(t->GetD(GetX(),GetY())) >3.) && fConstraint[fPass]) continue;
SortTrackHypothesys(fCurrentEsdTrack,20,0); //MI change
//
- AliITStrackV2 * besttrack = GetBestHypothesys(fCurrentEsdTrack,t,15);
+ AliITStrackMI * besttrack = GetBestHypothesys(fCurrentEsdTrack,t,15);
if (!besttrack) continue;
besttrack->SetLabel(tpcLabel);
// besttrack->CookdEdx();
}
-
-Int_t AliITStrackerMI::Clusters2Tracks(TTree *tpcTree, TTree *itsTree) {
- //--------------------------------------------------------------------
- // This functions reconstructs ITS tracks
- // The clusters must be already loaded !
- //--------------------------------------------------------------------
- Int_t nentr=0; TObjArray itsTracks(15000);
-
- Warning("Clusters2Tracks(TTree *, TTree *)",
- "Will be removed soon ! Use Clusters2Tracks(AliESD *) instead.");
-
- {/* Read TPC tracks */
- AliTPCtrack *itrack=new AliTPCtrack;
- TBranch *branch=tpcTree->GetBranch("tracks");
- if (!branch) {
- Error("Clusters2Tracks","Can't get the branch !");
- return 1;
- }
- tpcTree->SetBranchAddress("tracks",&itrack);
- nentr=(Int_t)tpcTree->GetEntries();
-
- Info("Clusters2Tracks","Number of TPC tracks: %d\n",nentr);
-
- for (Int_t i=0; i<nentr; i++) {
- tpcTree->GetEvent(i);
- AliITStrackV2 *t=0;
- try {
- t=new AliITStrackV2(*itrack);
- } catch (const Char_t *msg) {
- Warning("Clusters2Tracks",msg);
- delete t;
- continue;
- }
- if (TMath::Abs(t->GetD())>4) {
- delete t;
- continue;
- }
-
- if (CorrectForDeadZoneMaterial(t)!=0) {
- Warning("Clusters2Tracks",
- "failed to correct for the material in the dead zone !\n");
- delete t;
- continue;
- }
-
- itsTracks.AddLast(t);
- }
- delete itrack;
- }
- itsTracks.Sort();
- nentr=itsTracks.GetEntriesFast();
-
-
- AliITStrackV2 *otrack=&fBestTrack;
- TBranch *branch=itsTree->GetBranch("tracks");
- if (!branch) itsTree->Branch("tracks","AliITStrackV2",&otrack,32000,3);
- else branch->SetAddress(&otrack);
-
- for (fPass=0; fPass<2; fPass++) {
- Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue;
- for (Int_t i=0; i<nentr; i++) {
- AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
- if (t==0) continue; //this track has been already tracked
- Int_t tpcLabel=t->GetLabel(); //save the TPC track label
-
- ResetTrackToFollow(*t);
- ResetBestTrack();
- /*
- for (FollowProlongation(); fI<kMaxLayer; fI++) {
- while (TakeNextProlongation()) FollowProlongation();
- }
- */
- FollowProlongationTree(t,i);
- if (fBestTrack.GetNumberOfClusters() == 0) continue;
-
- if (fConstraint[fPass]) {
- ResetTrackToFollow(*t);
- if (!RefitAt(3.7, &fTrackToFollow, &fBestTrack)) continue;
- ResetBestTrack();
- }
-
- fBestTrack.SetLabel(tpcLabel);
- //fBestTrack.CookdEdx();
- CookdEdx(&fBestTrack);
-
- CookLabel(&fBestTrack,0.); //For comparison only
- itsTree->Fill();
- //UseClusters(&fBestTrack);
- delete itsTracks.RemoveAt(i);
- }
- }
-
- nentr=(Int_t)itsTree->GetEntries();
- Info("Clusters2Tracks","Number of prolonged tracks: %d\n",nentr);
-
- itsTracks.Delete();
-
- return 0;
-}
-
Int_t AliITStrackerMI::PropagateBack(AliESD *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
if ((esd->GetStatus()&AliESDtrack::kITSin)==0) continue;
if (esd->GetStatus()&AliESDtrack::kITSout) continue;
- AliITStrackV2 *t=0;
+ AliITStrackMI *t=0;
try {
- t=new AliITStrackV2(*esd);
+ t=new AliITStrackMI(*esd);
} catch (const Char_t *msg) {
Warning("PropagateBack",msg);
delete t;
if (esd->GetStatus()&AliESDtrack::kTPCout)
if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
- AliITStrackV2 *t=0;
+ AliITStrackMI *t=0;
try {
- t=new AliITStrackV2(*esd);
+ t=new AliITStrackMI(*esd);
} catch (const Char_t *msg) {
Warning("RefitInward",msg);
delete t;
}
-void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdindex)
+void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex)
{
//--------------------------------------------------------------------
// Follow prolongation tree
//setup tree of the prolongations
//
- static AliITStrackV2 tracks[7][100];
- AliITStrackV2 *currenttrack;
- static AliITStrackV2 currenttrack1;
- static AliITStrackV2 currenttrack2;
- static AliITStrackV2 backuptrack;
+ static AliITStrackMI tracks[7][100];
+ AliITStrackMI *currenttrack;
+ static AliITStrackMI currenttrack1;
+ static AliITStrackMI currenttrack2;
+ static AliITStrackMI backuptrack;
Int_t ntracks[7];
Int_t nindexes[7][100];
Float_t normalizedchi2[100];
for (Int_t ilayer=0;ilayer<6;ilayer++) ntracks[ilayer]=0;
otrack->fNSkipped=0;
- new (&(tracks[6][0])) AliITStrackV2(*otrack);
+ new (&(tracks[6][0])) AliITStrackMI(*otrack);
ntracks[6]=1;
nindexes[6][0]=0;
//
if (itrack>1&&tracks[ilayer+1][nindexes[ilayer+1][itrack]].fNUsed>2. && nused>3) continue;
}
- new(¤ttrack1) AliITStrackV2(tracks[ilayer+1][nindexes[ilayer+1][itrack]]);
+ new(¤ttrack1) AliITStrackMI(tracks[ilayer+1][nindexes[ilayer+1][itrack]]);
if (ilayer==3 || ilayer==1) {
Double_t rs=0.5*(fgLayers[ilayer+1].GetR() + r);
Double_t d=0.0034, x0=38.6;
//propagate to the intersection
const AliITSdetector &det=layer.GetDetector(idet);
phi=det.GetPhi();
- new(¤ttrack2) AliITStrackV2(currenttrack1);
+ new(¤ttrack2) AliITStrackMI(currenttrack1);
if (!currenttrack1.Propagate(phi,det.GetR())) {
continue;
}
Float_t pz = (z - c->GetZ()) , py=(y - c->GetY());
if (pz*pz*msz+py*py*msy>1.) continue;
//
- new (&backuptrack) AliITStrackV2(currenttrack2);
+ new (&backuptrack) AliITStrackMI(currenttrack2);
change = kTRUE;
currenttrack =¤ttrack2;
if (!currenttrack->Propagate(det.GetPhi(),det.GetR())) {
- new (currenttrack) AliITStrackV2(backuptrack);
+ new (currenttrack) AliITStrackMI(backuptrack);
change = kFALSE;
continue;
}
if (chi2<kMaxChi2s[ilayer]){
if (c->GetQ()==0) deadzone=1; // take dead zone only once
if (ntracks[ilayer]>=100) continue;
- AliITStrackV2 * updatetrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackV2(*currenttrack);
+ AliITStrackMI * updatetrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(*currenttrack);
updatetrack->fClIndex[ilayer]=0;
if (change){
- new (¤ttrack2) AliITStrackV2(backuptrack);
+ new (¤ttrack2) AliITStrackMI(backuptrack);
}
if (c->GetQ()!=0){
if (!UpdateMI(updatetrack,c,chi2,(ilayer<<28)+ci)) continue;
} // loop over possible cluster prolongation
// if (fConstraint[fPass]&&itrack<2&¤ttrack1.fNSkipped==0 && deadzone==0){
if (itrack<2&¤ttrack1.fNSkipped==0 && deadzone==0&&ntracks[ilayer]<100){
- AliITStrackV2* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackV2(currenttrack1);
+ AliITStrackMI* vtrack = new (&tracks[ilayer][ntracks[ilayer]]) AliITStrackMI(currenttrack1);
vtrack->fClIndex[ilayer]=0;
fI = ilayer;
Double_t d=GetEffectiveThickness(0,0); //Think of this !!!!
//printf("%d\t%d\t%d\t%d\t%d\t%d\n",ntracks[0],ntracks[1],ntracks[2],ntracks[3],ntracks[4],ntracks[5]);
for (Int_t i=0;i<TMath::Min(20,ntracks[0]);i++) {
- AliITStrackV2 & track= tracks[0][nindexes[0][i]];
+ AliITStrackMI & track= tracks[0][nindexes[0][i]];
if (!fConstraint[fPass]&&track.fNormChi2[0]>7.)continue;
- AddTrackHypothesys(new AliITStrackV2(track), esdindex);
+ AddTrackHypothesys(new AliITStrackMI(track), esdindex);
}
for (Int_t i=0;i<TMath::Min(4,ntracks[1]);i++) {
- AliITStrackV2 & track= tracks[1][nindexes[1][i]];
+ AliITStrackMI & track= tracks[1][nindexes[1][i]];
if (track.GetNumberOfClusters()<4) continue;
if (!fConstraint[fPass]&&track.fNormChi2[1]>7.)continue;
if (fConstraint[fPass]) track.fNSkipped+=1;
track.fNSkipped = 6-track.fN+track.fNDeadZone;
}
}
- AddTrackHypothesys(new AliITStrackV2(track), esdindex);
+ AddTrackHypothesys(new AliITStrackMI(track), esdindex);
}
//}
if (!fConstraint[fPass]){
for (Int_t i=0;i<TMath::Min(3,ntracks[2]);i++) {
- AliITStrackV2 & track= tracks[2][nindexes[2][i]];
+ AliITStrackMI & track= tracks[2][nindexes[2][i]];
if (track.GetNumberOfClusters()<4) continue;
if (!fConstraint[fPass]&&track.fNormChi2[2]>7.)continue;
if (fConstraint[fPass]) track.fNSkipped+=2;
track.fNSkipped = 6-track.fN+track.fNDeadZone;
}
}
- AddTrackHypothesys(new AliITStrackV2(track), esdindex);
+ AddTrackHypothesys(new AliITStrackMI(track), esdindex);
}
}
}
}
Bool_t
-AliITStrackerMI::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) {
+AliITStrackerMI::RefitAt(Double_t xx,AliITStrackMI *t,const AliITStrackMI *c) {
//--------------------------------------------------------------------
// This function refits the track "t" at the position "x" using
// the clusters from "c"
}
-Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackV2 * track, Int_t mode)
+Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode)
{
//
// calculate normalized chi2
}
-Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackV2 * track1, AliITStrackV2 * track2)
+Double_t AliITStrackerMI::GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2)
{
//
// return matching chi2 between two tracks
- AliITStrackV2 track3(*track2);
+ AliITStrackMI track3(*track2);
track3.Propagate(track1->GetAlpha(),track1->GetX());
TMatrixD vec(5,1);
vec(0,0)=track1->fP0-track3.fP0;
}
-Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackV2 * track, Float_t fac)
+Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac)
{
//
// calculate normalized chi2
}
-Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackV2 * forwardtrack, AliITStrackV2 * backtrack)
+Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack)
{
//
// calculate normalized chi2
return fgLayers[l].GetWeight(c);
}
-void AliITStrackerMI::RegisterClusterTracks(AliITStrackV2* track,Int_t id)
+void AliITStrackerMI::RegisterClusterTracks(AliITStrackMI* track,Int_t id)
{
//---------------------------------------------
// register track to the list
}
}
}
-void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackV2* track, Int_t id)
+void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id)
{
//---------------------------------------------
// unregister track from the list
}
}
}
-Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackV2* track,Int_t id, Int_t list[6], AliITSclusterV2 *clist[6])
+Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id, Int_t list[6], AliITSclusterV2 *clist[6])
{
//-------------------------------------------------------------
//get number of shared clusters
return shared;
}
-Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackV2 *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
+Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6],Int_t overlist[6])
{
//
// find first shared track
}
-AliITStrackV2 * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t th0, Float_t th1){
+AliITStrackMI * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t th0, Float_t th1){
//
// try to find track hypothesys without conflicts
// with minimal chi2;
TClonesArray *arr1 = (TClonesArray*)fTrackHypothesys.At(trackID1);
Int_t entries1 = arr1->GetEntriesFast();
TClonesArray *arr2 = (TClonesArray*)fTrackHypothesys.At(trackID2);
- if (!arr2) return (AliITStrackV2*) arr1->UncheckedAt(0);
+ if (!arr2) return (AliITStrackMI*) arr1->UncheckedAt(0);
Int_t entries2 = arr2->GetEntriesFast();
- if (entries2<=0) return (AliITStrackV2*) arr1->UncheckedAt(0);
+ if (entries2<=0) return (AliITStrackMI*) arr1->UncheckedAt(0);
//
- AliITStrackV2 * track10=(AliITStrackV2*) arr1->UncheckedAt(0);
- AliITStrackV2 * track20=(AliITStrackV2*) arr2->UncheckedAt(0);
+ AliITStrackMI * track10=(AliITStrackMI*) arr1->UncheckedAt(0);
+ AliITStrackMI * track20=(AliITStrackMI*) arr2->UncheckedAt(0);
if (TMath::Abs(1./track10->Get1Pt())>0.5+TMath::Abs(1/track20->Get1Pt())) return track10;
for (Int_t itrack=0;itrack<entries1;itrack++){
- AliITStrackV2 * track=(AliITStrackV2*) arr1->UncheckedAt(itrack);
+ AliITStrackMI * track=(AliITStrackMI*) arr1->UncheckedAt(itrack);
UnRegisterClusterTracks(track,trackID1);
}
//
for (Int_t itrack=0;itrack<entries2;itrack++){
- AliITStrackV2 * track=(AliITStrackV2*) arr2->UncheckedAt(itrack);
+ AliITStrackMI * track=(AliITStrackMI*) arr2->UncheckedAt(itrack);
UnRegisterClusterTracks(track,trackID2);
}
Int_t index1=0;
Float_t * ny2 = GetNy(trackID2), * nz2 = GetNz(trackID2);
for (Int_t itrack1=0;itrack1<entries1;itrack1++){
- AliITStrackV2 * track1=(AliITStrackV2*) arr1->UncheckedAt(itrack1);
+ AliITStrackMI * track1=(AliITStrackMI*) arr1->UncheckedAt(itrack1);
//if (track1->fFakeRatio>0) continue;
RegisterClusterTracks(track1,trackID1);
for (Int_t itrack2=0;itrack2<entries2;itrack2++){
- AliITStrackV2 * track2=(AliITStrackV2*) arr2->UncheckedAt(itrack2);
+ AliITStrackMI * track2=(AliITStrackMI*) arr2->UncheckedAt(itrack2);
// Float_t current = w1*track1->fChi2MIP[0]+w2*track2->fChi2MIP[0];
//if (track2->fFakeRatio>0) continue;
// if (maxconflicts<4 && maxchi2<th0){
if (maxchi2<th0*2.){
Float_t orig = track10->fFakeRatio*track10->GetNumberOfClusters();
- AliITStrackV2* track1=(AliITStrackV2*) arr1->UncheckedAt(index1);
+ AliITStrackMI* track1=(AliITStrackMI*) arr1->UncheckedAt(index1);
track1->fChi2MIP[5] = maxconflicts;
track1->fChi2MIP[6] = maxchi2;
track1->fChi2MIP[7] = 0.01+orig-(track1->fFakeRatio*track1->GetNumberOfClusters());
}
for (Int_t itrack=0;itrack<entries1;itrack++){
- AliITStrackV2 * track=(AliITStrackV2*) arr1->UncheckedAt(itrack);
+ AliITStrackMI * track=(AliITStrackMI*) arr1->UncheckedAt(itrack);
UnRegisterClusterTracks(track,trackID1);
}
//
for (Int_t itrack=0;itrack<entries2;itrack++){
- AliITStrackV2 * track=(AliITStrackV2*) arr2->UncheckedAt(itrack);
+ AliITStrackMI * track=(AliITStrackMI*) arr2->UncheckedAt(itrack);
UnRegisterClusterTracks(track,trackID2);
}
}
-void AliITStrackerMI::AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex)
+void AliITStrackerMI::AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex)
{
//------------------------------------------------------------------
// add track to the list of hypothesys
//- find preliminary besttrack as a reference
Float_t minchi2=10000;
Int_t maxn=0;
- AliITStrackV2 * besttrack=0;
+ AliITStrackMI * besttrack=0;
for (Int_t itrack=0;itrack<array->GetEntriesFast();itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (!track) continue;
Float_t chi2 = NormalizedChi2(track,0);
//
Int_t * index = new Int_t[entries];
for (Int_t i=0;i<entries;i++) chi2[i] =10000;
for (Int_t itrack=0;itrack<entries;itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (track){
track->fChi2MIP[0] = GetNormalizedChi2(track, mode);
if (track->fChi2MIP[0]<kMaxChi2PerCluster[0])
}
//
TMath::Sort(entries,chi2,index,kFALSE);
- besttrack = (AliITStrackV2*)array->At(index[0]);
+ besttrack = (AliITStrackMI*)array->At(index[0]);
if (besttrack&&besttrack->fChi2MIP[0]<kMaxChi2PerCluster[0]){
for (Int_t i=0;i<6;i++){
if (besttrack->fClIndex[i]>0){
// calculate one more time with updated normalized errors
for (Int_t i=0;i<entries;i++) chi2[i] =10000;
for (Int_t itrack=0;itrack<entries;itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (track){
track->fChi2MIP[0] = GetNormalizedChi2(track,mode);
if (track->fChi2MIP[0]<kMaxChi2PerCluster[0])
if (entries>0){
TObjArray * newarray = new TObjArray();
TMath::Sort(entries,chi2,index,kFALSE);
- besttrack = (AliITStrackV2*)array->At(index[0]);
+ besttrack = (AliITStrackMI*)array->At(index[0]);
if (besttrack){
//
for (Int_t i=0;i<6;i++){
Float_t minn = besttrack->GetNumberOfClusters()-3;
Int_t accepted=0;
for (Int_t i=0;i<entries;i++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(index[i]);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(index[i]);
if (!track) continue;
if (accepted>maxcut) break;
track->fChi2MIP[0] = GetNormalizedChi2(track,mode);
-AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 * original, Int_t checkmax)
+AliITStrackMI * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackMI * original, Int_t checkmax)
{
//-------------------------------------------------------------
// try to find best hypothesy
Int_t entries = array->GetEntriesFast();
if (!entries) return 0;
Float_t minchi2 = 100000;
- AliITStrackV2 * besttrack=0;
+ AliITStrackMI * besttrack=0;
//
- AliITStrackV2 * backtrack = new AliITStrackV2(*original);
- AliITStrackV2 * forwardtrack = new AliITStrackV2(*original);
+ AliITStrackMI * backtrack = new AliITStrackMI(*original);
+ AliITStrackMI * forwardtrack = new AliITStrackMI(*original);
//
for (Int_t i=0;i<entries;i++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(i);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(i);
if (!track) continue;
track->fChi2MIP[1] = 1000000;
track->fChi2MIP[2] = 1000000;
track->fChi2MIP[3] = 1000000;
//
// backtrack
- backtrack = new(backtrack) AliITStrackV2(*track);
+ backtrack = new(backtrack) AliITStrackMI(*track);
backtrack->ResetCovariance();
backtrack->ResetCovariance();
backtrack->ResetClusters();
if(!isOK) continue;
//
//forward track - without constraint
- forwardtrack = new(forwardtrack) AliITStrackV2(*original);
+ forwardtrack = new(forwardtrack) AliITStrackMI(*original);
forwardtrack->ResetClusters();
x = track->GetX();
if (!RefitAt(x,forwardtrack,track)) continue;
forwardtrack->fChi2MIP[ichi] = track->fChi2MIP[ichi];
}
if (chi2 < minchi2){
- //besttrack = new AliITStrackV2(*forwardtrack);
+ //besttrack = new AliITStrackMI(*forwardtrack);
besttrack = track;
besttrack->SetLabel(track->GetLabel());
besttrack->fFakeRatio = track->fFakeRatio;
delete forwardtrack;
Int_t accepted=0;
for (Int_t i=0;i<entries;i++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(i);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(i);
if (!track) continue;
if (accepted>checkmax || track->fChi2MIP[3]>kMaxChi2PerCluster[3]*6. ||
(track->GetNumberOfClusters()<besttrack->GetNumberOfClusters()-1.)||
array->Compress();
SortTrackHypothesys(esdindex,checkmax,1);
array = (TObjArray*) fTrackHypothesys.At(esdindex);
- besttrack = (AliITStrackV2*)array->At(0);
+ besttrack = (AliITStrackMI*)array->At(0);
if (!besttrack) return 0;
besttrack->fChi2MIP[8]=0;
fBestTrackIndex[esdindex]=0;
entries = array->GetEntriesFast();
- AliITStrackV2 *longtrack =0;
+ AliITStrackMI *longtrack =0;
minchi2 =1000;
Float_t minn=besttrack->GetNumberOfClusters()+besttrack->fNDeadZone;
for (Int_t itrack=entries-1;itrack>0;itrack--){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(itrack);
if (!track->fConstrain) continue;
if (track->GetNumberOfClusters()+track->fNDeadZone<minn) continue;
if (track->fChi2MIP[0]-besttrack->fChi2MIP[0]>0.0) continue;
Bool_t cansign = kTRUE;
for (Int_t itrack=0;itrack<entries; itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(i);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(i);
if (!track) continue;
if (track->fChi2MIP[0]>besttrack->fChi2MIP[0]+2.*shared+1.) break;
if ( (track->fClIndex[ilayer]>0) && (track->fClIndex[ilayer]!=besttrack->fClIndex[ilayer])){
Int_t nentries = itsTracks.GetEntriesFast();
for (Int_t i=0;i<nentries;i++){
- AliITStrackV2* track = (AliITStrackV2*)itsTracks.At(i);
+ AliITStrackMI* track = (AliITStrackMI*)itsTracks.At(i);
if (!track) continue;
TObjArray * array = (TObjArray*) fTrackHypothesys.At(i);
if (!array) continue;
if (array->GetEntriesFast()<=0) continue;
//
- AliITStrackV2* longtrack=0;
+ AliITStrackMI* longtrack=0;
Float_t minn=0;
Float_t maxchi2=1000;
for (Int_t j=0;j<array->GetEntriesFast();j++){
- AliITStrackV2* track = (AliITStrackV2*)array->At(j);
+ AliITStrackMI* track = (AliITStrackMI*)array->At(j);
if (!track) continue;
if (track->GetNumberOfClusters()+track->fNDeadZone<minn) continue;
if (track->GetNumberOfClusters()+track->fNDeadZone>minn) maxchi2 = track->fChi2MIP[0];
longtrack=track;
break;
}
- AliITStrackV2 * besttrack = (AliITStrackV2*)array->At(0);
+ AliITStrackMI * besttrack = (AliITStrackMI*)array->At(0);
if (!longtrack) {longtrack = besttrack;}
else besttrack= longtrack;
if (besttrack){
}
-void AliITStrackerMI::CookLabel(AliITStrackV2 *track,Float_t wrong) const {
+void AliITStrackerMI::CookLabel(AliITStrackMI *track,Float_t wrong) const {
//--------------------------------------------------------------------
//This function "cooks" a track label. If label<0, this track is fake.
//--------------------------------------------------------------------
-void AliITStrackerMI::CookdEdx(AliITStrackV2* track)
+void AliITStrackerMI::CookdEdx(AliITStrackMI* track)
{
//
//
}
-Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackV2* track, const AliITSclusterV2 *cluster,Int_t layer)
+Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSclusterV2 *cluster,Int_t layer)
{
//
//
}
-Int_t AliITStrackerMI::UpdateMI(AliITStrackV2* track, const AliITSclusterV2* cl,Double_t chi2,Int_t index) const
+Int_t AliITStrackerMI::UpdateMI(AliITStrackMI* track, const AliITSclusterV2* cl,Double_t chi2,Int_t index) const
{
//
//
}
-void AliITStrackerMI::UpdateESDtrack(AliITStrackV2* track, ULong_t flags) const
+void AliITStrackerMI::UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const
{
//
//
track->UpdateESDtrack(flags);
- AliITStrackV2 * oldtrack = (AliITStrackV2*)(track->fESDtrack->GetITStrack());
+ AliITStrackMI * oldtrack = (AliITStrackMI*)(track->fESDtrack->GetITStrack());
if (oldtrack) delete oldtrack;
- track->fESDtrack->SetITStrack(new AliITStrackV2(*track));
+ track->fESDtrack->SetITStrack(new AliITStrackMI(*track));
}
for (Int_t i=0;i<entries;i++){
TObjArray * array = (TObjArray*)fTrackHypothesys.At(i);
if (!array) continue;
- AliITStrackV2 * track = (AliITStrackV2*)array->At(fBestTrackIndex[i]);
+ AliITStrackMI * track = (AliITStrackMI*)array->At(fBestTrackIndex[i]);
if (track){
dist[i] = TMath::Sqrt(track->fD[0]*track->fD[0]+track->fD[1]*track->fD[1]);
trackarray.AddAt(track,i);
}
}
for (Int_t itrack0=0;itrack0<entries;itrack0++){
- AliITStrackV2 * track0 = (AliITStrackV2*)trackarray.At(itrack0);
+ AliITStrackMI * track0 = (AliITStrackMI*)trackarray.At(itrack0);
if (!track0) continue;
if (dist[itrack0]<0.2) continue;
for (Int_t itrack1=itrack0+1;itrack1<entries;itrack1++){
- AliITStrackV2 * track1 = (AliITStrackV2*)trackarray.At(itrack1);
+ AliITStrackMI * track1 = (AliITStrackMI*)trackarray.At(itrack1);
if (!track1) continue;
if (dist[itrack1]<0.2) continue;
if (track1->fP4*track0->fP4>0) continue; //the same sign
Int_t bestpair[2];
//
for (Int_t itrack0=0;itrack0<entries0;itrack0++){
- AliITStrackV2 * track0 = (AliITStrackV2*)array0->At(itrack0);
+ AliITStrackMI * track0 = (AliITStrackMI*)array0->At(itrack0);
if (!track0) continue;
if (track0->fX<criticalradius-1) continue;
if (track0->fX>criticalradius+5) continue;
for (Int_t itrack1=0;itrack1<entries1;itrack1++){
- AliITStrackV2 * track1 = (AliITStrackV2*)array1->At(itrack1);
+ AliITStrackMI * track1 = (AliITStrackMI*)array1->At(itrack1);
if (!track1) continue;
if (track1->fX<criticalradius-1) continue;
if (track1->fX>criticalradius+5) continue;
//-------------------------------------------------------------------------
// ITS tracker
-// reads AliITSclusterMI clusters and creates AliITStrackV2 tracks
-// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
-// Marian Ivanov, CERN, Marian.Ivanov@cern.ch
+// reads AliITSclusterMI clusters and creates AliITStrackMI tracks
+// Origin: Marian Ivanov, CERN, Marian.Ivanov@cern.ch
//-------------------------------------------------------------------------
#include <TObjArray.h>
#include "AliTracker.h"
-#include "AliITStrackV2.h"
+#include "AliITStrackMI.h"
#include "AliITSclusterV2.h"
-class AliITSclusterV2;
class AliESD;
class AliITSgeom;
class TTree;
class AliV0vertex;
-
class AliITSRecV0Info: public TObject {
friend class AliITStrackerMI;
protected:
{return fgLayers[layn].GetNumberOfClusters();}
Int_t LoadClusters(TTree *cf);
void UnloadClusters();
- Int_t Clusters2Tracks(TTree *in, TTree *out);
Int_t Clusters2Tracks(AliESD *event);
Int_t PropagateBack(AliESD *event);
Int_t RefitInward(AliESD *event);
- Bool_t RefitAt(Double_t x, AliITStrackV2 *seed, const AliITStrackV2 *t);
+ Bool_t RefitAt(Double_t x, AliITStrackMI *seed, const AliITStrackMI *t);
void SetupFirstPass(Int_t *flags, Double_t *cuts=0);
void SetupSecondPass(Int_t *flags, Double_t *cuts=0);
void UseClusters(const AliKalmanTrack *t, Int_t from=0) const;
void GetNTeor(Int_t layer, const AliITSclusterV2* cl, Float_t theta, Float_t phi, Float_t &ny, Float_t &nz);
Int_t GetError(Int_t layer, const AliITSclusterV2*cl, Float_t theta, Float_t phi, Float_t expQ, Float_t &erry, Float_t &errz);
- Double_t GetPredictedChi2MI(AliITStrackV2* track, const AliITSclusterV2 *cluster,Int_t layer);
- Int_t UpdateMI(AliITStrackV2* track, const AliITSclusterV2* cl,Double_t chi2,Int_t layer) const;
+ Double_t GetPredictedChi2MI(AliITStrackMI* track, const AliITSclusterV2 *cluster,Int_t layer);
+ Int_t UpdateMI(AliITStrackMI* track, const AliITSclusterV2* cl,Double_t chi2,Int_t layer) const;
class AliITSdetector {
public:
AliITSdetector(){}
Double_t TestV0(AliHelix *h1, AliHelix *h2, AliITSRecV0Info *vertex); //try to find V0 - return DCA
Double_t FindBestPair(Int_t esdtrack0, Int_t esdtrack1,AliITSRecV0Info *vertex); // try to find best pair from the tree of track hyp.
void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
- void CookLabel(AliITStrackV2 *t,Float_t wrong) const;
+ void CookLabel(AliITStrackMI *t,Float_t wrong) const;
Double_t GetEffectiveThickness(Double_t y, Double_t z) const;
- void FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdindex);
+ void FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex);
void ResetBestTrack() {
- fBestTrack.~AliITStrackV2();
- new(&fBestTrack) AliITStrackV2(fTrackToFollow);
+ fBestTrack.~AliITStrackMI();
+ new(&fBestTrack) AliITStrackMI(fTrackToFollow);
}
- void ResetTrackToFollow(const AliITStrackV2 &t) {
- fTrackToFollow.~AliITStrackV2();
- new(&fTrackToFollow) AliITStrackV2(t);
+ void ResetTrackToFollow(const AliITStrackMI &t) {
+ fTrackToFollow.~AliITStrackMI();
+ new(&fTrackToFollow) AliITStrackMI(t);
}
- void CookdEdx(AliITStrackV2* track);
- Double_t GetNormalizedChi2(AliITStrackV2 * track, Int_t mode);
- Double_t GetTruncatedChi2(AliITStrackV2 * track, Float_t fac);
- Double_t NormalizedChi2(AliITStrackV2 * track, Int_t layer);
- Double_t GetInterpolatedChi2(AliITStrackV2 * forwardtrack, AliITStrackV2 * backtrack);
- Double_t GetMatchingChi2(AliITStrackV2 * track1, AliITStrackV2 * track2);
+ void CookdEdx(AliITStrackMI* track);
+ Double_t GetNormalizedChi2(AliITStrackMI * track, Int_t mode);
+ Double_t GetTruncatedChi2(AliITStrackMI * track, Float_t fac);
+ Double_t NormalizedChi2(AliITStrackMI * track, Int_t layer);
+ Double_t GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack);
+ Double_t GetMatchingChi2(AliITStrackMI * track1, AliITStrackMI * track2);
Double_t GetDeadZoneProbability(Double_t zpos, Double_t zerr);
Float_t *GetWeight(Int_t index);
- void AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex);
+ void AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex);
void SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mode);
- AliITStrackV2 * GetBestHypothesys(Int_t esdindex, AliITStrackV2 * original, Int_t checkmax);
+ AliITStrackMI * GetBestHypothesys(Int_t esdindex, AliITStrackMI * original, Int_t checkmax);
void GetBestHypothesysMIP(TObjArray &itsTracks);
- void RegisterClusterTracks(AliITStrackV2* track, Int_t id);
- void UnRegisterClusterTracks(AliITStrackV2* track, Int_t id);
- Float_t GetNumberOfSharedClusters(AliITStrackV2* track,Int_t id, Int_t list[6], AliITSclusterV2 *clist[6]);
- Int_t GetOverlapTrack(AliITStrackV2 *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
- AliITStrackV2 * GetBest2Tracks(Int_t trackID1, Int_t treackID2, Float_t th0, Float_t th1);
+ void RegisterClusterTracks(AliITStrackMI* track, Int_t id);
+ void UnRegisterClusterTracks(AliITStrackMI* track, Int_t id);
+ Float_t GetNumberOfSharedClusters(AliITStrackMI* track,Int_t id, Int_t list[6], AliITSclusterV2 *clist[6]);
+ Int_t GetOverlapTrack(AliITStrackMI *track, Int_t trackID, Int_t &shared, Int_t clusterlist[6], Int_t overlist[6]);
+ AliITStrackMI * GetBest2Tracks(Int_t trackID1, Int_t treackID2, Float_t th0, Float_t th1);
Float_t * GetErrY(Int_t trackindex) const {return &fCoeficients[trackindex*48];}
Float_t * GetErrZ(Int_t trackindex) const {return &fCoeficients[trackindex*48+12];}
Float_t * GetNy(Int_t trackindex) const {return &fCoeficients[trackindex*48+24];}
Float_t * GetNz(Int_t trackindex) const {return &fCoeficients[trackindex*48+36];}
void SignDeltas( TObjArray *ClusterArray, Float_t zv);
void MakeCoeficients(Int_t ntracks);
- void UpdateESDtrack(AliITStrackV2* track, ULong_t flags) const;
+ void UpdateESDtrack(AliITStrackMI* track, ULong_t flags) const;
Int_t fI; // index of the current layer
static AliITSlayer fgLayers[kMaxLayer];// ITS layers
- AliITStrackV2 fTracks[kMaxLayer]; // track estimations at the ITS layers
- AliITStrackV2 fBestTrack; // "best" track
- AliITStrackV2 fTrackToFollow; // followed track
+ AliITStrackMI fTracks[kMaxLayer]; // track estimations at the ITS layers
+ AliITStrackMI fBestTrack; // "best" track
+ AliITStrackMI fTrackToFollow; // followed track
TObjArray fTrackHypothesys; // ! array with track hypothesys- ARRAY is the owner of tracks- MI
Int_t fBestTrackIndex[100000]; // ! index of the best track
Int_t fCurrentEsdTrack; // ! current esd track - MI
Float_t * fCoeficients; //! working array with errors and mean cluser shape
private:
AliITStrackerMI(const AliITStrackerMI * tracker){;}
- ClassDef(AliITStrackerMI,1) //ITS tracker V2
+ ClassDef(AliITStrackerMI,2) //ITS tracker MI
};
}
}
-inline Double_t AliITStrackerMI::NormalizedChi2(AliITStrackV2 * track, Int_t layer)
+inline Double_t AliITStrackerMI::NormalizedChi2(AliITStrackMI * track, Int_t layer)
{
//--------------------------------------------------------------------
//get normalize chi2
for(Int_t i=0;i<fGeom->GetNlayers();i++){
firstmod[i]=fGeom->GetModuleIndex(i+1,1,1);
}
- AliITStrackV2* otrack2;
+
Int_t nclusters = tr->GetNumberOfClustersSA();
TObjArray** listlayer = new TObjArray*[fGeom->GetNlayers()];
for(Int_t i=0;i<fGeom->GetNlayers();i++){
//fit with Kalman filter using AliITStrackerMI::RefitAt()
- AliITStrackV2* ot = new AliITStrackV2(*trac);
+ AliITStrackMI* ot = new AliITStrackSA(*trac);
ot->ResetCovariance();
ot->ResetClusters();
if(RefitAt(49.,ot,trac)){ //fit from layer 1 to layer 6
- otrack2 = new AliITStrackV2(*ot);
+ AliITStrackMI *otrack2 = new AliITStrackMI(*ot);
otrack2->ResetCovariance();
otrack2->ResetClusters();
//fit from layer 6 to layer 1
fI=kMaxLayer;
fPass=0;
- fConstraint[0]=1; fConstraint[1]=0;
+ fConstraint[0]=1; fConstraint[1]=0;//-1;
Double_t xyz[]={kXV,kYV,kZV}, ers[]={kSigmaXV,kSigmaYV,kSigmaZV};
SetVertex(xyz,ers);
branch->SetAddress(&clusters);
Int_t j=0;
- Int_t detector=0;
for (Int_t i=0; i<kMaxLayer; i++) {
Int_t ndet=fgLayers[i].GetNdetectors();
Int_t jmax = j + fgLayers[i].GetNladders()*ndet;
Int_t ncl=clusters->GetEntriesFast();
while (ncl--) {
AliITSclusterV2 *c=(AliITSclusterV2*)clusters->UncheckedAt(ncl);
- detector = c->GetDetectorIndex();
fgLayers[i].InsertCluster(new AliITSclusterV2(*c));
}
clusters->Delete();
- //add dead zone virtual "cluster"
-
- if (i<1){
- for (Float_t ydead = -2.; ydead < 2. ; ydead+=0.05){
- Int_t lab[4] = {0,0,0,detector};
- Int_t info[3] = {0,0,0};
- Float_t hit[5]={ydead,0,1,0.01,0};
- fgLayers[i].InsertCluster(new AliITSclusterV2(lab, hit, info));
- //
- hit[1]=-7.;
- fgLayers[i].InsertCluster(new AliITSclusterV2(lab, hit, info));
- }
- }
-
}
- //
fgLayers[i].ResetRoad(); //road defined by the cluster density
}
delete t;
continue;
}
- if (TMath::Abs(t->GetD())>5) {
+ if (TMath::Abs(t->GetD())>4) {
delete t;
continue;
}
delete t;
continue;
}
- t->SetReconstructed(kFALSE);
itsTracks.AddLast(t);
}
} /* End Read ESD tracks */
itsTracks.Sort();
Int_t nentr=itsTracks.GetEntriesFast();
- fTrackHypothesys.Expand(nentr);
+
Int_t ntrk=0;
for (fPass=0; fPass<2; fPass++) {
Int_t &constraint=fConstraint[fPass]; if (constraint<0) continue;
for (Int_t i=0; i<nentr; i++) {
- fCurrentEsdTrack = i;
AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
- if (t==0) continue; //this track has been already tracked
- if (t->GetReconstructed()) continue; //this track was already "succesfully" reconstructed
- if ( (TMath::Abs(t->GetD(GetX(),GetY())) >2.) && fConstraint[fPass]) continue;
- if ( (TMath::Abs(t->GetZat(GetX())-GetZ())>2.) && fConstraint[fPass]) continue;
-
+ if (t==0) continue; //this track has been already tracked
Int_t tpcLabel=t->GetLabel(); //save the TPC track label
ResetTrackToFollow(*t);
ResetBestTrack();
for (FollowProlongation(); fI<kMaxLayer; fI++) {
- while (TakeNextProlongation()) {
- FollowProlongation();
- }
+ while (TakeNextProlongation()) FollowProlongation();
}
- SortTrackHypothesys(fCurrentEsdTrack,0.9); //MI change
- CompressTrackHypothesys(fCurrentEsdTrack,0.90,2); //MI change
-
- /*
if (fBestTrack.GetNumberOfClusters() == 0) continue;
-
+
if (fConstraint[fPass]) {
- ResetTrackToFollow(*t);
- if (!RefitAt(3.7, &fTrackToFollow, &fBestTrack)) continue;
- ResetBestTrack();
- }
-
+ ResetTrackToFollow(*t);
+ if (!RefitAt(3.7, &fTrackToFollow, &fBestTrack)) continue;
+ ResetBestTrack();
+ }
+
fBestTrack.SetLabel(tpcLabel);
fBestTrack.CookdEdx();
CookLabel(&fBestTrack,0.); //For comparison only
fBestTrack.UpdateESDtrack(AliESDtrack::kITSin);
- //UseClusters(&fBestTrack);
+ UseClusters(&fBestTrack);
delete itsTracks.RemoveAt(i);
ntrk++;
- */
- AliITStrackV2 * besttrack = GetBestHypothesys(fCurrentEsdTrack,t,5);
- if (!besttrack) continue;
- besttrack->SetLabel(tpcLabel);
- besttrack->CookdEdx();
- besttrack->SetFakeRatio(1.);
- CookLabel(besttrack,0.); //For comparison only
- // besttrack->UpdateESDtrack(AliESDtrack::kITSin);
-
- if (besttrack->GetChi2()/besttrack->GetNumberOfClusters()>3.5){
- if ( (TMath::Abs(besttrack->GetD(GetX(),GetY()))>0.4) && fConstraint[fPass]) {
- CompressTrackHypothesys(fCurrentEsdTrack,0.0,0);
- continue;
- }
- if ( (TMath::Abs(besttrack->GetZat(GetX()) -GetZ() )>0.4) && fConstraint[fPass]){
- CompressTrackHypothesys(fCurrentEsdTrack,0.0,0);
- continue;
- }
- }
-
- //delete itsTracks.RemoveAt(i);
- t->SetReconstructed();
- ntrk++;
-
}
}
-
- for (Int_t i=0; i<nentr; i++) {
- fCurrentEsdTrack = i;
- AliITStrackV2 *t=(AliITStrackV2*)itsTracks.UncheckedAt(i);
- if (t==0) continue;
- Int_t tpcLabel=t->GetLabel(); //save the TPC track label
- AliITStrackV2 * besttrack = GetBestHypothesysMIP(fCurrentEsdTrack,t);
- if (!besttrack) continue;
-
- besttrack->SetLabel(tpcLabel);
- besttrack->CookdEdx();
- besttrack->SetFakeRatio(1.);
- CookLabel(besttrack,0.); //For comparison only
- besttrack->UpdateESDtrack(AliESDtrack::kITSin);
- }
- //
itsTracks.Delete();
- //
- Int_t entries = fTrackHypothesys.GetEntriesFast();
- for (Int_t ientry=0;ientry<entries;ientry++){
- TObjArray * array =(TObjArray*)fTrackHypothesys.UncheckedAt(ientry);
- if (array) array->Delete();
- delete fTrackHypothesys.RemoveAt(ientry);
- }
- fTrackHypothesys.Delete();
Info("Clusters2Tracks","Number of prolonged tracks: %d\n",ntrk);
return 0;
}
-
Int_t AliITStrackerV2::PropagateBack(AliESD *event) {
//--------------------------------------------------------------------
// This functions propagates reconstructed ITS tracks back
//fTrackToFollow.CookdEdx();
CookLabel(&fTrackToFollow,0.); //For comparison only
fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout);
- //UseClusters(&fTrackToFollow);
+ UseClusters(&fTrackToFollow);
ntrk++;
}
delete t;
if ((esd->GetStatus()&AliESDtrack::kITSout) == 0) continue;
if (esd->GetStatus()&AliESDtrack::kITSrefit) continue;
if (esd->GetStatus()&AliESDtrack::kTPCout)
- if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
+ if ((esd->GetStatus()&AliESDtrack::kTPCrefit)==0) continue;
AliITStrackV2 *t=0;
try {
ResetTrackToFollow(*t);
fTrackToFollow.ResetClusters();
- if ((esd->GetStatus()&AliESDtrack::kTPCin)==0)
- fTrackToFollow.ResetCovariance();
-
//Refitting...
if (RefitAt(3.7, &fTrackToFollow, t)) {
fTrackToFollow.SetLabel(t->GetLabel());
fTrackToFollow.CookdEdx();
- CookLabel(&fTrackToFollow,0.0); //For comparison only
+ CookLabel(&fTrackToFollow,0.); //For comparison only
if (fTrackToFollow.PropagateTo(3.,0.0028,65.19)) {//The beam pipe
Double_t a=fTrackToFollow.GetAlpha();
if (fTrackToFollow.Propagate(fv+a,xv)) {
fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSrefit);
- //UseClusters(&fTrackToFollow);
+ UseClusters(&fTrackToFollow);
{
AliITSclusterV2 c; c.SetY(yv); c.SetZ(GetZ());
c.SetSigmaY2(GetSigmaY()*GetSigmaY());
return;
}
- // if (TMath::Abs(fTrackToFollow.GetZ()-GetZ()) > r+dz) return;
+ if (TMath::Abs(fTrackToFollow.GetZ()-GetZ()) > r+dz) return;
//Double_t dy=4*TMath::Sqrt(track.GetSigmaY2() + kSigmaY2[i]);
- if (TMath::Abs(track.GetSnp()>kMaxSnp)) {
- fI--;
- continue; // MI
- }
if (dy < 0.5*TMath::Abs(track.GetSnp())) dy=0.5*TMath::Abs(track.GetSnp());
if (dy > kMaxRoad) {
//Warning("FollowProlongation","too broad road in Y !\n");
fI--;
//take another prolongation
- if (!TakeNextProlongation()){
- //skipped++;
- fTrackToFollow.IncrementNSkipped();
- if (fLayersNotToSkip[fI]||fTrackToFollow.GetNSkipped()>1) return;
- }
- if (fTrackToFollow.GetNUsed()>1) return;
- if (fTrackToFollow.GetNUsed()+fTrackToFollow.GetNSkipped()>1) return;
- if ( (fI<3) && ( fTrackToFollow.GetChi2()/fTrackToFollow.GetNumberOfClusters()>kChi2PerCluster)) return;
+ if (!TakeNextProlongation())
+ if (fLayersNotToSkip[fI]) return;
+
}
//deal with the best track
Int_t ncl=fTrackToFollow.GetNumberOfClusters();
Int_t nclb=fBestTrack.GetNumberOfClusters();
- if (ncl){
- if (ncl<4) return;
- if ( (ncl<6) && (fTrackToFollow.GetChi2()/float(ncl))>3) return;
- if (fTrackToFollow.GetChi2()/ncl>5.5) return;
- fTrackToFollow.CookdEdx();
- if (fTrackToFollow.GetESDtrack()->GetTPCsignal()>80.)
- if ((fTrackToFollow.GetdEdx()/fTrackToFollow.GetESDtrack()->GetTPCsignal())<0.35){
- // mismatch in dedx
- return;
- }
- //
- fTrackToFollow.SetLabel(fTrackToFollow.GetESDtrack()->GetLabel());
- CookLabel(&fTrackToFollow,0.); //
- //
- if ( (nclb>3) && ((fTrackToFollow.GetChi2()/ncl)<(3*fBestTrack.GetChi2()/(nclb))))
- AddTrackHypothesys(new AliITStrackV2(fTrackToFollow), fCurrentEsdTrack);
- else
- if (ncl>3) AddTrackHypothesys(new AliITStrackV2(fTrackToFollow), fCurrentEsdTrack);
- if (ncl >= nclb) {
- Double_t chi2=fTrackToFollow.GetChi2();
- if (chi2/ncl < kChi2PerCluster) {
- if (ncl > nclb ) {
- ResetBestTrack();
+ if (ncl)
+ if (ncl >= nclb) {
+ Double_t chi2=fTrackToFollow.GetChi2();
+ if (chi2/ncl < kChi2PerCluster) {
+ if (ncl > nclb || chi2 < fBestTrack.GetChi2()) {
+ ResetBestTrack();
}
- if ( (ncl == nclb) && chi2 < fBestTrack.GetChi2()) {
- ResetBestTrack();
- }
- }
- }
+ }
}
+
}
Int_t AliITStrackerV2::TakeNextProlongation() {
Double_t chi2=12345.;
while ((c=layer.GetNextCluster(ci))!=0) {
Int_t idet=c->GetDetectorIndex();
+
if (fTrackToFollow.GetDetectorIndex()!=idet) {
const AliITSdetector &det=layer.GetDetector(idet);
ResetTrackToFollow(fTracks[fI]);
if (chi2>=kMaxChi2) return 0;
if (!c) return 0;
- if (c->IsUsed()&&c->GetNy()<5) { //shared factor
- chi2+=1;
- chi2*=2*(1./(TMath::Max(c->GetNy(),1)));
- }
- if (c->GetQ()==0){ //dead zone virtual cluster
- chi2*=4.;
- chi2+=20;
- fTrackToFollow.IncrementNUsed();
- return 1;
- }
- //if ((fI<2)&&chi2>kMaxChi2In) return 0;
if (!fTrackToFollow.Update(c,chi2,(fI<<28)+ci)) {
//Warning("TakeNextProlongation","filtering failed !\n");
return 0;
}
- if (c->IsUsed()&&c->GetNy()<5) fTrackToFollow.IncrementNUsed();
+
if (fTrackToFollow.GetNumberOfClusters()>1)
if (TMath::Abs(fTrackToFollow.GetD())>4) return 0;
Double_t d=GetEffectiveThickness(0,0); //Think of this !!!!
Double_t xyz[]={GetX(),GetY(),GetZ()};
Double_t ers[]={GetSigmaX(),GetSigmaY(),GetSigmaZ()};
- Double_t deltad = TMath::Abs(fTrackToFollow.GetD(GetX(),GetY()));
- Double_t deltaz = TMath::Abs(fTrackToFollow.GetZat(GetX())-GetZ());
-
- if ( (fI==4) && (deltad>2.0 || deltaz>1.5)) return 0; // don't "improve" secondaries
- if ( (fI==3) && (deltad>1.5 || deltaz>0.9)) return 0; // don't "improve" secondaries
- if ( (fI==2) && (deltad>0.9 || deltaz>0.6)) return 1; // don't "improve" secondaries
- if ( (fI==1) && (deltad>0.3 || deltaz>0.3)) return 1; // don't "improve" secondaries
- if ( (fI==0) && (deltad>0.1 || deltaz>0.1)) return 1; // don't "improve" secondaries
-
fTrackToFollow.Improve(d,xyz,ers);
}
//--------------------------------------------------------------------
delete[] fDetectors;
for (Int_t i=0; i<fN; i++) delete fClusters[i];
- for (Int_t i=0; i<kMaxClusterPerLayer;i++) fClusterWeight[i]=0;
}
void AliITStrackerV2::AliITSlayer::ResetClusters() {
// This function removes loaded clusters
//--------------------------------------------------------------------
for (Int_t i=0; i<fN; i++) delete fClusters[i];
- for (Int_t i=0; i<kMaxClusterPerLayer;i++) fClusterWeight[i]=0;
fN=0;
fI=0;
}
-void AliITStrackerV2::AliITSlayer::ResetWeights() {
- //--------------------------------------------------------------------
- // This function reset weights of the clusters
- //--------------------------------------------------------------------
- for (Int_t i=0; i<kMaxClusterPerLayer;i++) fClusterWeight[i]=0;
-}
-
void AliITStrackerV2::AliITSlayer::ResetRoad() {
//--------------------------------------------------------------------
// This function calculates the road defined by the cluster density
for (Int_t i=fI; i<fN; i++) {
const AliITSclusterV2 *c=fClusters[i];
if (c->GetZ() > fZmax) break;
- // if (c->IsUsed()) continue;
+ if (c->IsUsed()) continue;
const AliITSdetector &det=GetDetector(c->GetDetectorIndex());
Double_t y=fR*det.GetPhi() + c->GetY();
return kTRUE;
}
-
-Float_t *AliITStrackerV2::GetWeight(Int_t index) {
- //--------------------------------------------------------------------
- // Return pointer to a given cluster
- //--------------------------------------------------------------------
- Int_t l=(index & 0xf0000000) >> 28;
- Int_t c=(index & 0x0fffffff) >> 00;
- return fgLayers[l].GetWeight(c);
-}
-
-
-
void AliITStrackerV2::UseClusters(const AliKalmanTrack *t, Int_t from) const {
//--------------------------------------------------------------------
// This function marks clusters assigned to the track
if (c->GetSigmaZ2()>0.1) c->Use();
}
-
-
-void AliITStrackerV2::AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex)
-{
- //------------------------------------------------------------------
- // add track to the list of hypothesys
- //------------------------------------------------------------------
-
- if (esdindex>=fTrackHypothesys.GetEntriesFast()) fTrackHypothesys.Expand(esdindex*2+10);
- //
- TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
- if (!array) {
- array = new TObjArray(10);
- fTrackHypothesys.AddAt(array,esdindex);
- }
- array->AddLast(track);
-}
-
-void AliITStrackerV2::SortTrackHypothesys(Int_t esdindex, Float_t likelihoodlevel)
-{
- //-------------------------------------------------------------------
- // compress array of track hypothesys
- // keep only maxsize best hypothesys
- //-------------------------------------------------------------------
- if (esdindex>fTrackHypothesys.GetEntriesFast()) return;
- if (! (fTrackHypothesys.At(esdindex)) ) return;
- TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
- Int_t entries = array->GetEntriesFast();
-
- Float_t * chi2 = new Float_t[entries];
- Float_t * probability = new Float_t[entries];
- Float_t sumprobabilityall=0;
- Int_t * index = new Int_t[entries];
- //
- //
- for (Int_t itrack=0;itrack<array->GetEntriesFast();itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- //
- if (track && track->GetNumberOfClusters()>(track->GetNUsed()+track->GetNSkipped())){
- //
- chi2[itrack] = track->GetChi2()/(track->GetNumberOfClusters()-track->GetNUsed()-track->GetNSkipped());
- if (track->GetESDtrack())
- if (track->GetESDtrack()->GetTPCsignal()>80){
- track->CookdEdx();
- if ((track->GetdEdx()/track->GetESDtrack()->GetTPCsignal())<0.4){
- Float_t factor = 2.+10.*(0.6-track->GetdEdx()/track->GetESDtrack()->GetTPCsignal());
- chi2[itrack]*= factor; //mismatch in dEdx
- }
- }
- }
- else
- chi2[itrack] = 10000000.;
- probability[itrack] = 1./(0.3+chi2[itrack]);
- sumprobabilityall+=probability[itrack];
- }
-
- TMath::Sort(entries,chi2,index,kFALSE);
- TObjArray * newarray = new TObjArray();
- Float_t sumprobability = 0.;
- for (Int_t i=0;i<entries;i++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(index[i]);
- if (!track) break;
- if (chi2[index[i]]<30){
- newarray->AddLast(array->RemoveAt(index[i]));
- track->SetChi2MIP(0,chi2[index[i]]); // base chi 2
- sumprobability+= probability[index[i]]/sumprobabilityall;
- if (sumprobability> likelihoodlevel) break;
- }
- else{
- delete array->RemoveAt(index[i]);
- }
- }
-
- array->Delete();
- delete fTrackHypothesys.RemoveAt(esdindex);
- fTrackHypothesys.AddAt(newarray,esdindex);
-
- delete [] chi2;
- delete [] probability;
- delete [] index;
-
-}
-
-
-void AliITStrackerV2::CompressTrackHypothesys(Int_t esdindex, Float_t likelihoodlevel, Int_t maxsize)
-{
- //
- //
- if (esdindex>fTrackHypothesys.GetEntriesFast()) return;
- if (! (fTrackHypothesys.At(esdindex)) ) return;
- TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
- Int_t entries = array->GetEntriesFast();
- //
- if (likelihoodlevel>0.000001){
- Float_t *probability = new Float_t[entries];
- for (Int_t i=0;i<entries;i++) probability[i]=0.;
- Float_t sumprobabilityall=0;
- Int_t *index = new Int_t[entries];
-
- for (Int_t itrack=0;itrack<entries;itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- probability[itrack]=0;
- if (!track) continue;
- probability[itrack] = 1./(0.3+track->GetChi2MIP(0));
- sumprobabilityall += probability[itrack];
- //
- }
- if (sumprobabilityall<=0.000000000000001){
- return;
- }
- for (Int_t itrack=0;itrack<entries;itrack++){
- probability[itrack]/=sumprobabilityall;
- }
-
- TMath::Sort(entries, probability, index, kTRUE);
- //
- TObjArray * newarray = new TObjArray();
- Float_t sumprobability = 0.;
- for (Int_t i=0;i<entries;i++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(index[i]);
- if (!track) continue;
- newarray->AddLast(array->RemoveAt(index[i]));
- sumprobability+= probability[index[i]];
- if (sumprobability> likelihoodlevel) break;
- if (i>maxsize) break;
- }
-
- array->Delete();
- delete fTrackHypothesys.RemoveAt(esdindex);
- fTrackHypothesys.AddAt(newarray,esdindex);
- //
- delete []index;
- delete []probability;
- }
- else{
- array->Delete();
- delete fTrackHypothesys.RemoveAt(esdindex);
- }
-}
-
-
-AliITStrackV2 * AliITStrackerV2::GetBestHypothesys(Int_t esdindex, AliITStrackV2 * original, Int_t checkmax)
-{
- //-------------------------------------------------------------
- // try to find best hypothesy
- // currently - minimal chi2 of track+backpropagated track+matching to the tpc track
- //-------------------------------------------------------------
- if (fTrackHypothesys.GetEntriesFast()<=esdindex) return 0;
- TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
- if (!array) return 0;
- Int_t entries = array->GetEntriesFast();
- if (!entries) return 0;
- Float_t minchi2 = 100000;
- Int_t maxn = 3;
- AliITStrackV2 * besttrack=0;
- Int_t accepted =0;
- Int_t maxindex=0;
- //
- Float_t sumz2=0;
- Float_t sumy2=0;
- Float_t sumall=0;
- for (Int_t itrack=0;itrack<entries; itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- sumall++;
- sumz2+=track->GetSigmaZ2();
- sumy2+=track->GetSigmaY2();
- }
- sumz2/=sumall;
- sumy2/=sumall;
-
- Float_t dedxmismatch=1;
- for (Int_t i=0;i<entries;i++){
- maxindex = i;
- AliITStrackV2 * track = (AliITStrackV2*)array->At(i);
- if (!track) continue;
- track->SetChi2MIP(1,1000000);
- track->SetChi2MIP(2,1000000);
-
- if ( (track->GetNumberOfClusters()-track->GetNSkipped()-track->GetNUsed())<2) continue;
- //
- if (track->GetESDtrack())
- if (track->GetESDtrack()->GetTPCsignal()>80){
- track->CookdEdx();
- if ((track->GetdEdx()/track->GetESDtrack()->GetTPCsignal())<0.4){
- //mismatch in dEdx
- dedxmismatch= 2.+ 10.*(0.6-track->GetdEdx()/track->GetESDtrack()->GetTPCsignal());
- }
- }
-
- // track->SetLabel(original->GetLabel());
- //CookLabel(track,0.0);
- //if (track->GetFakeRatio()>0.01) continue;
- //
- //
- // backtrack
- AliITStrackV2 * backtrack = new AliITStrackV2(*track);
- backtrack->ResetCovariance();
- backtrack->ResetClusters();
- Double_t x = original->GetX();
- if (!RefitAt(x,backtrack,track)){
- delete backtrack;
- delete array->RemoveAt(i);
- continue;
- }
- if ( (backtrack->GetChi2() / float(backtrack->GetNumberOfClusters()-track->GetNSkipped()-track->GetNUsed()-0.5))>6)
- {
- delete backtrack;
- delete array->RemoveAt(i);
- continue;
- }
- Double_t deltac = backtrack->GetC()-original->GetC();
- Double_t deltatgl = backtrack->GetTgl()-original->GetTgl();
- //
- Double_t poolc2 = (deltac*deltac)/(original->GetCov44()+backtrack->GetCov44());
- Double_t pooltgl2 = (deltatgl*deltatgl)/(original->GetCov33()+backtrack->GetCov33());
- if ((poolc2+pooltgl2)>32){ //4 sigma
- delete backtrack;
- delete array->RemoveAt(i);
- continue;
- }
- //Double_t bpoolc = (deltac*deltac)/(original->GetCov44());
- //Double_t bpooltgl = (deltatgl*deltatgl)/(original->GetCov33());
-
- //
- //forward track - without constraint
- AliITStrackV2 * forwardtrack = new AliITStrackV2(*original);
- // forwardtrack->ResetCovariance();
- forwardtrack->ResetClusters();
- x = track->GetX();
- if (!RefitAt(x,forwardtrack,track)){
- delete forwardtrack;
- delete backtrack;
- delete array->RemoveAt(i);
- continue;
- }
- if ( (forwardtrack->GetChi2()/float(forwardtrack->GetNumberOfClusters()-track->GetNSkipped()-track->GetNUsed()))>6) {
- delete forwardtrack;
- delete backtrack;
- delete array->RemoveAt(i);
- continue;
- }
- //
- accepted++;
- if (accepted>checkmax){
- delete backtrack;
- delete forwardtrack;
- break;
- }
- Double_t chi2 = (backtrack->GetChi2()/(backtrack->GetNumberOfClusters()-1-track->GetNSkipped()-track->GetNUsed())+
- forwardtrack->GetChi2()/(forwardtrack->GetNumberOfClusters()-track->GetNSkipped()-track->GetNUsed()));
- // bpoolc+bpooltgl;
- // chi2 *= (forwardtrack->GetSigmaZ2()/sumz2+forwardtrack->GetSigmaY2()/sumy2);
- chi2 *= dedxmismatch;
- //
- //
- track->SetChi2MIP(1,backtrack->GetChi2()/(backtrack->GetNumberOfClusters()-1-track->GetNSkipped()-track->GetNUsed()));
- track->SetChi2MIP(2,forwardtrack->GetChi2()/(forwardtrack->GetNumberOfClusters()-track->GetNSkipped()-track->GetNUsed()));
- track->SetChi2MIP(3,poolc2+pooltgl2);
- //
-
- if (track->GetNumberOfClusters()>maxn){
- delete besttrack;
- besttrack = new AliITStrackV2(*forwardtrack);
- maxn = track->GetNumberOfClusters();
- minchi2 = chi2;
- delete backtrack;
- delete forwardtrack;
- continue;
- }
- //
- if (chi2 < minchi2){
- besttrack = new AliITStrackV2(*forwardtrack);
- minchi2 = chi2;
- }
- delete backtrack;
- delete forwardtrack;
- }
- //
- //
- if (!besttrack || besttrack->GetNumberOfClusters()<4) {
- delete besttrack;
- return 0;
- }
-
- //
- besttrack->SetLabel(original->GetLabel());
- CookLabel(besttrack,0.0);
- //
- // calculate "weight of the cluster"
- //
-
- {
- //sign usage information for clusters
- Int_t clusterindex[6][100];
- Double_t clusterweight[6][100];
- for (Int_t ilayer=0;ilayer<6;ilayer++)
- for (Int_t icluster=0;icluster<100;icluster++){
- clusterindex[ilayer][icluster] = -1;
- clusterweight[ilayer][icluster] = 0;
- }
- //printf("%d\t%d\n",esdindex, entries);
- //
- Float_t sumchi2=0;
- for (Int_t itrack=0;itrack<entries; itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- if (track->GetChi2MIP(1)>1000) continue; //not accepted
- sumchi2 +=1./(0.3+track->GetChi2MIP(1)+track->GetChi2MIP(2));
- }
- for (Int_t itrack=0;itrack<entries;itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- if (track->GetChi2MIP(1)>1000) continue; //not accepted
- for (Int_t icluster=0;icluster<track->GetNumberOfClusters();icluster++){
- Int_t tindex = track->GetClusterIndex(icluster);
- Int_t ilayer = (tindex & 0xf0000000) >> 28;
- if (tindex<0) continue;
- Int_t cindex =0;
- //
- for (cindex=0;cindex<100;cindex++){
- if (clusterindex[ilayer][cindex]<0) break;
- if (clusterindex[ilayer][cindex]==tindex) break;
- }
- if (cindex>100) break;
- if (clusterindex[ilayer][cindex]!=tindex) clusterindex[ilayer][cindex] = tindex;
- clusterweight[ilayer][cindex]+= (1./(0.3+track->GetChi2MIP(1)+track->GetChi2MIP(2)))* (1./sumchi2);
- Float_t *weight = GetWeight(tindex);
-
- if (weight){
- *weight+= (1./(0.3+track->GetChi2MIP(1)+track->GetChi2MIP(2)))* (1./sumchi2);
- }
- }
- }
-
- if (besttrack->GetChi2()/besttrack->GetNumberOfClusters()>3.5) return besttrack; //don't sign clusters
- Int_t current=0;
- Double_t deltad = besttrack->GetD(GetX(),GetY());
- Double_t deltaz = besttrack->GetZat(GetX()) - GetZ();
- Double_t deltaprim = TMath::Sqrt(deltad*deltad+deltaz*deltaz);
-
- for (Int_t icluster=0;icluster<besttrack->GetNumberOfClusters();icluster++){
- Int_t index = besttrack->GetClusterIndex(icluster);
- Int_t ilayer = (index & 0xf0000000) >> 28;
- AliITSclusterV2 *c = (AliITSclusterV2*)GetCluster(index);
- if (!c) continue;
- //
- for (Int_t icluster=0;icluster<100;icluster++){
- // sign non "doubt" clusters as used
- if (clusterindex[ilayer][icluster]!=index) continue;
- // Float_t * weight = GetWeight(index);
- //if (weight) if (*weight>1){
- // if (c->IsUsed()) continue;
- // c->Use();
- //}
- if ( (ilayer*0.2+0.2)<deltaprim) continue; // secondaries
- if (c->GetNy()>4) continue; // don sign cluster
- if ( (ilayer>1&&clusterweight[ilayer][icluster]>0.7) || (ilayer<2&&clusterweight[ilayer][icluster]>0.8) ){
- current++;
- if (c->IsUsed()) continue;
- c->Use();
- }
- }
- }
- }
-
- //
- return besttrack;
-}
-
-
-AliITStrackV2 * AliITStrackerV2::GetBestHypothesysMIP(Int_t esdindex, AliITStrackV2 * original)
-{
- //-------------------------------------------------------------
- // try to find best hypothesy
- // currently - minimal chi2 of track+backpropagated track+matching to the tpc track
- //-------------------------------------------------------------
- if (fTrackHypothesys.GetEntriesFast()<=esdindex) return 0;
- TObjArray * array = (TObjArray*) fTrackHypothesys.At(esdindex);
- if (!array) return 0;
- Int_t entries = array->GetEntriesFast();
- if (!entries) return 0;
- AliITStrackV2 * besttrack=0;
- //
- //sign usage information for clusters
- Int_t clusterindex[6][100];
- Double_t clusterweight[6][100];
- for (Int_t ilayer=0;ilayer<6;ilayer++)
- for (Int_t icluster=0;icluster<100;icluster++){
- clusterindex[ilayer][icluster] = -1;
- clusterweight[ilayer][icluster] = 0;
- }
- //printf("%d\t%d\n",esdindex, entries);
- //
- Float_t sumchi2=0;
- for (Int_t itrack=0;itrack<entries; itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- if (track->GetChi2MIP(1)>1000) continue; //not accepted - before
- sumchi2 +=1./(0.3+track->GetChi2MIP(1)+track->GetChi2MIP(2));
- }
- //
- // get cluster weight
- for (Int_t itrack=0;itrack<entries;itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- if (track->GetChi2MIP(1)>1000) continue; // track not accepted in previous iterration
- for (Int_t icluster=0;icluster<track->GetNumberOfClusters();icluster++){
- Int_t tindex = track->GetClusterIndex(icluster);
- Int_t ilayer = (tindex & 0xf0000000) >> 28;
- if (tindex<0) continue;
- Int_t cindex =0;
- //
- for (cindex=0;cindex<100;cindex++){
- if (clusterindex[ilayer][cindex]<0) break;
- if (clusterindex[ilayer][cindex]==tindex) break;
- }
- if (cindex>100) break;
- if (clusterindex[ilayer][cindex]!=tindex) clusterindex[ilayer][cindex] = tindex;
- clusterweight[ilayer][cindex]+= (1./(0.3+track->GetChi2MIP(1)+track->GetChi2MIP(2)))* (1./sumchi2);
- }
- }
- //
- // get cluster relative sharing - factor
- //
- //
- for (Int_t ilayer=0;ilayer<6;ilayer++)
- for (Int_t cindex=0;cindex<100;cindex++){
- if (clusterindex[ilayer][cindex]<0) continue;
- Int_t tindex = clusterindex[ilayer][cindex];
- Float_t *weight = GetWeight(tindex);
- if (!weight){
- printf("Problem 1\n"); // not existing track
- continue;
- }
- if (*weight<(clusterweight[ilayer][cindex]-0.00001)){
- printf("Problem 2\n"); // not normalized probability
- continue;
- }
- AliITSclusterV2 *c = (AliITSclusterV2*)GetCluster(tindex);
- if (c->GetNy()<5){
- clusterweight[ilayer][cindex]/= *weight;
- }
- else{
- Float_t weight2 = TMath::Max(*weight-0.5*clusterweight[ilayer][cindex],0.0000001);
- clusterweight[ilayer][cindex]/= weight2;
- if ( clusterweight[ilayer][cindex]>1) clusterweight[ilayer][cindex] =1.;
- }
- }
- //
- //take to the account sharing factor
- //
- Float_t chi2 =10000000;
- Float_t sharefactor=0;
- Float_t minchi2 = 100000000;
- Float_t secchi2 = 100000000;
- Float_t norm=0;
- for (Int_t itrack=0;itrack<entries; itrack++){
- AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack);
- if (!track) continue;
- if (track->GetChi2MIP(1)>1000) continue; //not accepted - before
- chi2 = track->GetChi2MIP(1);
- Float_t newchi2=0;
- sharefactor=0;
- norm =0;
- //
- for (Int_t icluster=0;icluster<track->GetNumberOfClusters();icluster++){
- Int_t tindex = track->GetClusterIndex(icluster);
- Int_t ilayer = (tindex & 0xf0000000) >> 28;
- if (tindex<0) continue;
- Int_t cindex =0;
- Float_t cchi2 = (track->GetDy(ilayer)*track->GetDy(ilayer))/(track->GetSigmaY(ilayer)*track->GetSigmaY(ilayer)) +
- (track->GetDz(ilayer)*track->GetDz(ilayer))/(track->GetSigmaZ(ilayer)*track->GetSigmaZ(ilayer)) ;
- //
- for (cindex=0;cindex<100;cindex++){
- if (clusterindex[ilayer][cindex]<0) break;
- if (clusterindex[ilayer][cindex]==tindex) break;
- }
- if (cindex>100) continue;
- if (clusterweight[ilayer][cindex]>0.00001){
- sharefactor+= clusterweight[ilayer][cindex];
- cchi2/=clusterweight[ilayer][cindex];
- norm++;
- }
- newchi2+=cchi2;
- }
- newchi2/=(norm-track->GetNSkipped()-track->GetNUsed());
- track->SetChi2MIP(4,newchi2);
- //if (norm>0) sharefactor/=norm;
- //if (sharefactor<0.5) return 0;
- // chi2*=1./(0.5+sharefactor);
- if (newchi2<minchi2){
- besttrack = track;
- minchi2 = newchi2;
- }
- else{
- if (newchi2<secchi2){
- secchi2 = newchi2;
- }
- }
- //
- }
-
- //
- //
- if (!besttrack || besttrack->GetNumberOfClusters()<4) {
- return 0;
- }
- //
- if ((minchi2/secchi2)<0.7){
- //
- //increase the weight for clusters if the probability of other hypothesys is small
- Double_t deltad = besttrack->GetD(GetX(),GetY());
- Double_t deltaz = besttrack->GetZat(GetX()) - GetZ();
- Double_t deltaprim = TMath::Sqrt(deltad*deltad+deltaz*deltaz);
- //
- for (Int_t icluster=0;icluster<besttrack->GetNumberOfClusters();icluster++){
- Int_t index = besttrack->GetClusterIndex(icluster);
- Int_t ilayer = (index & 0xf0000000) >> 28;
- AliITSclusterV2 *c = (AliITSclusterV2*)GetCluster(index);
- if (!c) continue;
- if (c->GetNy()>3) continue;
- if ( (ilayer*0.2+0.2)<deltaprim) continue; // secondaries
- Float_t * weight = GetWeight(index);
- *weight*=2.;
- *weight+=1.;
- }
- }
-
-
- besttrack->SetLabel(original->GetLabel());
- CookLabel(besttrack,0.0);
-
- //
- return besttrack;
-}
-
// reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
-
-#include <TObjArray.h>
-
#include "AliTracker.h"
#include "AliITSrecoV2.h"
#include "AliITStrackV2.h"
void UseClusters(const AliKalmanTrack *t, Int_t from=0) const;
- class AliITSdetector {
+ class AliITSdetector {
public:
AliITSdetector(){}
AliITSdetector(Double_t r,Double_t phi) {fR=r; fPhi=phi;}
};
class AliITSlayer {
- friend class AliITStrackerV2;
public:
AliITSlayer();
AliITSlayer(Double_t r, Double_t p, Double_t z, Int_t nl, Int_t nd);
~AliITSlayer();
Int_t InsertCluster(AliITSclusterV2 *c);
void ResetClusters();
- void ResetWeights();
void SelectClusters(Double_t zmi,Double_t zma,Double_t ymi,Double_t yma);
const AliITSclusterV2 *GetNextCluster(Int_t &ci);
void ResetRoad();
Double_t GetRoad() const {return fRoad;}
Double_t GetR() const {return fR;}
- AliITSclusterV2 *GetCluster(Int_t i) const {return i<fN? fClusters[i]:0;}
- Float_t *GetWeight(Int_t i) {return i<fN ?&fClusterWeight[i]:0;}
+ AliITSclusterV2 *GetCluster(Int_t i) const {return fClusters[i];}
AliITSdetector &GetDetector(Int_t n) const { return fDetectors[n]; }
Int_t FindDetectorIndex(Double_t phi, Double_t z) const;
Double_t GetThickness(Double_t y, Double_t z, Double_t &x0) const;
Int_t GetNumberOfClusters() const {return fN;}
Int_t GetNladders() const {return fNladders;}
Int_t GetNdetectors() const {return fNdetectors;}
- Int_t FindClusterIndex(Double_t z) const;
protected:
Double_t fR; // mean radius of this layer
Double_t fPhiOffset; // offset of the first detector in Phi
AliITSdetector *fDetectors; // array of detectors
Int_t fN; // number of clusters
AliITSclusterV2 *fClusters[kMaxClusterPerLayer]; // pointers to clusters
- Float_t fClusterWeight[kMaxClusterPerLayer]; // probabilistic weight of the cluster
Double_t fZmax; // edges
Double_t fYmin; // of the
Double_t fYmax; // "window"
Int_t fI; // index of the current cluster within the "window"
Double_t fRoad; // road defined by the cluster density
+ Int_t FindClusterIndex(Double_t z) const;
};
-
+
protected:
void CookLabel(AliKalmanTrack *t,Float_t wrong) const;
Double_t GetEffectiveThickness(Double_t y, Double_t z) const;
fTrackToFollow.~AliITStrackV2();
new(&fTrackToFollow) AliITStrackV2(t);
}
- Float_t *GetWeight(Int_t index);
- void AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex);
- void SortTrackHypothesys(Int_t esdindex, Float_t likelihoodlevel);
- void CompressTrackHypothesys(Int_t esdindex, Float_t likelihoodlevel, Int_t maxsize);
- AliITStrackV2 * GetBestHypothesys(Int_t esdindex, AliITStrackV2 * original, Int_t checkmax);
- AliITStrackV2 * GetBestHypothesysMIP(Int_t esdindex, AliITStrackV2 * original);
Int_t fI; // index of the current layer
static AliITSlayer fgLayers[kMaxLayer];// ITS layers
AliITStrackV2 fTracks[kMaxLayer]; // track estimations at the ITS layers
AliITStrackV2 fBestTrack; // "best" track
AliITStrackV2 fTrackToFollow; // followed track
- TObjArray fTrackHypothesys; // ! array with track hypothesys- ARRAY is the owner of tracks- MI
- Int_t fCurrentEsdTrack; // ! current esd track - MI
Int_t fPass; // current pass through the data
Int_t fConstraint[2]; // constraint flags
Int_t fLayersNotToSkip[kMaxLayer]; // layer masks
Int_t fLastLayerToTrackTo; // the innermost layer to track to
+
ClassDef(AliITStrackerV2,1) //ITS tracker V2
};
Int_t tpcLabel=t->GetLabel();
if (tpcLabel<0) return;
AliTracker::CookLabel(t,wrong);
- if (tpcLabel!=TMath::Abs(t->GetLabel())){
- t->SetFakeRatio(1.);
- }
- if (tpcLabel !=t->GetLabel()) {
- t->SetLabel(-tpcLabel);
- }
+ if (tpcLabel != t->GetLabel()) t->SetLabel(-tpcLabel);
}
#endif
#pragma link C++ class AliITSclusterV2+;
#pragma link C++ class AliITStrackV2+;
#pragma link C++ class AliITStrackerV2+;
+#pragma link C++ class AliITStrackMI+;
#pragma link C++ class AliITStrackerMI+;
#pragma link C++ class AliITSRecV0Info+;
#pragma link C++ class AliV0vertex+;
AliITSclusterV2.cxx \
AliITStrackV2.cxx \
AliITStrackerV2.cxx \
+ AliITStrackMI.cxx \
AliITStrackerMI.cxx \
AliITSVertexer.cxx \
AliITSVertexerIons.cxx \
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff