From: hristov Date: Tue, 12 Oct 2004 08:19:45 +0000 (+0000) Subject: Extracting AliITStrackMI from AliITStrackV2. Reverting AliITStrackerV2 to the version... X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=15dd636fe2589363908aa2f48504ba5fab2d5763;p=u%2Fmrichter%2FAliRoot.git Extracting AliITStrackMI from AliITStrackV2. Reverting AliITStrackerV2 to the version from the beginning of 2004. All Marians changes are now only in AliITStrackerMI, and AliITStrackerV2 contains the original code of Yuri. (Yu.Belikov) --- diff --git a/ITS/AliITStrackMI.cxx b/ITS/AliITStrackMI.cxx new file mode 100644 index 00000000000..1540888b8cb --- /dev/null +++ b/ITS/AliITStrackMI.cxx @@ -0,0 +1,298 @@ +/************************************************************************** + * 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 + +#include + +#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 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 (ckWARN) + 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; +} + diff --git a/ITS/AliITStrackMI.h b/ITS/AliITStrackMI.h new file mode 100644 index 00000000000..0ca9568526a --- /dev/null +++ b/ITS/AliITStrackMI.h @@ -0,0 +1,97 @@ +#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 + +#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 + + diff --git a/ITS/AliITStrackSA.cxx b/ITS/AliITStrackSA.cxx index f342f9bd7bb..19a95f9239d 100755 --- a/ITS/AliITStrackSA.cxx +++ b/ITS/AliITStrackSA.cxx @@ -29,7 +29,7 @@ ClassImp(AliITStrackSA) //_____________________________________ -AliITStrackSA:: AliITStrackSA() : AliITStrackV2(){ +AliITStrackSA:: AliITStrackSA() : AliITStrackMI(){ // Default constructor SetNumberOfClusters(0); SetNumberOfClustersSA(0); @@ -38,15 +38,15 @@ AliITStrackSA:: AliITStrackSA() : AliITStrackV2(){ //___________________________________________________ -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(); diff --git a/ITS/AliITStrackSA.h b/ITS/AliITStrackSA.h index 477a7ff5749..2a4c8b6286b 100755 --- a/ITS/AliITStrackSA.h +++ b/ITS/AliITStrackSA.h @@ -9,15 +9,15 @@ // // //////////////////////////////////////////////////// -#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, @@ -38,7 +38,7 @@ class AliITStrackSA : public AliITStrackV2 { UInt_t fSain[fgkMaxNumberOfClusters]; // cluster index (SA) Int_t fNSA; // number of clusters SA - ClassDef(AliITStrackSA,1) + ClassDef(AliITStrackSA,2) }; #endif diff --git a/ITS/AliITStrackV2.cxx b/ITS/AliITStrackV2.cxx index 814a66c9885..35cfdccd8b5 100644 --- a/ITS/AliITStrackV2.cxx +++ b/ITS/AliITStrackV2.cxx @@ -25,7 +25,6 @@ #include #include "AliCluster.h" -#include "AliTPCtrack.h" #include "AliESDtrack.h" #include "AliITStrackV2.h" @@ -58,65 +57,12 @@ AliITStrackV2::AliITStrackV2():AliKalmanTrack(), 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 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 *) : @@ -163,28 +109,14 @@ AliKalmanTrack() { 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); } @@ -211,30 +143,6 @@ AliITStrackV2::AliITStrackV2(const AliITStrackV2& t) : AliKalmanTrack(t) { 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)); } //_____________________________________________________________________________ @@ -245,8 +153,8 @@ Int_t AliITStrackV2::Compare(const TObject *o) const { 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 (ckWARN) - 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) { @@ -378,22 +260,11 @@ Int_t AliITStrackV2::CorrectForMaterial(Double_t d, Double_t x0) { //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; @@ -505,12 +376,6 @@ Int_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, UInt_t index) { 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; @@ -558,84 +423,6 @@ Int_t AliITStrackV2::Update(const AliCluster* c, Double_t chi2, UInt_t index) { 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 @@ -722,9 +509,7 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) { 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 ****************** @@ -782,30 +567,6 @@ Int_t AliITStrackV2::Propagate(Double_t alp,Double_t xk) { 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 @@ -885,47 +646,6 @@ Int_t AliITStrackV2::Improve(Double_t x0,Double_t xyz[3],Double_t ers[3]) { 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 #include "AliITSgeom.h" -#include "AliTPCtrack.h" #include "AliESD.h" #include "AliITSclusterV2.h" #include "AliITStrackerMI.h" @@ -179,7 +177,7 @@ void AliITStrackerMI::UnloadClusters() { for (Int_t i=0; iGetStatus()&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; @@ -280,7 +278,7 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) { for (Int_t i=0; ifReconstructed&&(t->fNUsed<1.5)) continue; //this track was already "succesfully" reconstructed if ( (TMath::Abs(t->GetD(GetX(),GetY())) >3.) && fConstraint[fPass]) continue; @@ -296,7 +294,7 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) { 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(); @@ -339,106 +337,6 @@ Int_t AliITStrackerMI::Clusters2Tracks(AliESD *event) { } - -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; iGetEvent(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; iGetLabel(); //save the TPC track label - - ResetTrackToFollow(*t); - ResetBestTrack(); - /* - for (FollowProlongation(); fIFill(); - //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 @@ -454,9 +352,9 @@ Int_t AliITStrackerMI::PropagateBack(AliESD *event) { 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; @@ -516,9 +414,9 @@ Int_t AliITStrackerMI::RefitInward(AliESD *event) { 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; @@ -597,7 +495,7 @@ AliCluster *AliITStrackerMI::GetCluster(Int_t index) const { } -void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdindex) +void AliITStrackerMI::FollowProlongationTree(AliITStrackMI * otrack, Int_t esdindex) { //-------------------------------------------------------------------- // Follow prolongation tree @@ -605,17 +503,17 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin //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; // @@ -640,7 +538,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin 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; @@ -663,7 +561,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin //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; } @@ -726,11 +624,11 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin 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; } @@ -745,10 +643,10 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin if (chi2GetQ()==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; @@ -784,7 +682,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin } // 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 !!!! @@ -818,12 +716,12 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin //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;i7.)continue; - AddTrackHypothesys(new AliITStrackV2(track), esdindex); + AddTrackHypothesys(new AliITStrackMI(track), esdindex); } for (Int_t i=0;i7.)continue; if (fConstraint[fPass]) track.fNSkipped+=1; @@ -834,13 +732,13 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin 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;i7.)continue; if (fConstraint[fPass]) track.fNSkipped+=2; @@ -851,7 +749,7 @@ void AliITStrackerMI::FollowProlongationTree(AliITStrackV2 * otrack, Int_t esdin track.fNSkipped = 6-track.fN+track.fNDeadZone; } } - AddTrackHypothesys(new AliITStrackV2(track), esdindex); + AddTrackHypothesys(new AliITStrackMI(track), esdindex); } } } @@ -1423,7 +1321,7 @@ Int_t AliITStrackerMI::AliITSlayer::InRoad() const { } 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" @@ -1559,7 +1457,7 @@ AliITStrackerMI::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) { } -Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackV2 * track, Int_t mode) +Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackMI * track, Int_t mode) { // // calculate normalized chi2 @@ -1656,11 +1554,11 @@ Double_t AliITStrackerMI::GetNormalizedChi2(AliITStrackV2 * track, Int_t mode) } -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; @@ -1720,7 +1618,7 @@ Double_t AliITStrackerMI::GetDeadZoneProbability(Double_t zpos, Double_t zerr) } -Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackV2 * track, Float_t fac) +Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackMI * track, Float_t fac) { // // calculate normalized chi2 @@ -1749,7 +1647,7 @@ Double_t AliITStrackerMI::GetTruncatedChi2(AliITStrackV2 * track, Float_t fac) } -Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackV2 * forwardtrack, AliITStrackV2 * backtrack) +Double_t AliITStrackerMI::GetInterpolatedChi2(AliITStrackMI * forwardtrack, AliITStrackMI * backtrack) { // // calculate normalized chi2 @@ -1794,7 +1692,7 @@ Float_t *AliITStrackerMI::GetWeight(Int_t index) { 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 @@ -1811,7 +1709,7 @@ void AliITStrackerMI::RegisterClusterTracks(AliITStrackV2* track,Int_t id) } } } -void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackV2* track, Int_t id) +void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackMI* track, Int_t id) { //--------------------------------------------- // unregister track from the list @@ -1827,7 +1725,7 @@ void AliITStrackerMI::UnRegisterClusterTracks(AliITStrackV2* track, Int_t id) } } } -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 @@ -1874,7 +1772,7 @@ Float_t AliITStrackerMI::GetNumberOfSharedClusters(AliITStrackV2* track,Int_t id 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 @@ -1984,28 +1882,28 @@ Int_t AliITStrackerMI::GetOverlapTrack(AliITStrackV2 *track, Int_t trackID, Int_ } -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;itrackUncheckedAt(itrack); + AliITStrackMI * track=(AliITStrackMI*) arr1->UncheckedAt(itrack); UnRegisterClusterTracks(track,trackID1); } // for (Int_t itrack=0;itrackUncheckedAt(itrack); + AliITStrackMI * track=(AliITStrackMI*) arr2->UncheckedAt(itrack); UnRegisterClusterTracks(track,trackID2); } Int_t index1=0; @@ -2083,11 +1981,11 @@ AliITStrackV2 * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, Float_t * ny2 = GetNy(trackID2), * nz2 = GetNz(trackID2); for (Int_t itrack1=0;itrack1UncheckedAt(itrack1); + AliITStrackMI * track1=(AliITStrackMI*) arr1->UncheckedAt(itrack1); //if (track1->fFakeRatio>0) continue; RegisterClusterTracks(track1,trackID1); for (Int_t itrack2=0;itrack2UncheckedAt(itrack2); + AliITStrackMI * track2=(AliITStrackMI*) arr2->UncheckedAt(itrack2); // Float_t current = w1*track1->fChi2MIP[0]+w2*track2->fChi2MIP[0]; //if (track2->fFakeRatio>0) continue; @@ -2190,7 +2088,7 @@ AliITStrackV2 * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, // if (maxconflicts<4 && maxchi2fFakeRatio*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()); @@ -2207,12 +2105,12 @@ AliITStrackV2 * AliITStrackerMI::GetBest2Tracks(Int_t trackID1, Int_t trackID2, } for (Int_t itrack=0;itrackUncheckedAt(itrack); + AliITStrackMI * track=(AliITStrackMI*) arr1->UncheckedAt(itrack); UnRegisterClusterTracks(track,trackID1); } // for (Int_t itrack=0;itrackUncheckedAt(itrack); + AliITStrackMI * track=(AliITStrackMI*) arr2->UncheckedAt(itrack); UnRegisterClusterTracks(track,trackID2); } @@ -2248,7 +2146,7 @@ void AliITStrackerMI::UseClusters(const AliKalmanTrack *t, Int_t from) const { } -void AliITStrackerMI::AddTrackHypothesys(AliITStrackV2 * track, Int_t esdindex) +void AliITStrackerMI::AddTrackHypothesys(AliITStrackMI * track, Int_t esdindex) { //------------------------------------------------------------------ // add track to the list of hypothesys @@ -2278,9 +2176,9 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo //- 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;itrackGetEntriesFast();itrack++){ - AliITStrackV2 * track = (AliITStrackV2*)array->At(itrack); + AliITStrackMI * track = (AliITStrackMI*)array->At(itrack); if (!track) continue; Float_t chi2 = NormalizedChi2(track,0); // @@ -2324,7 +2222,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo Int_t * index = new Int_t[entries]; for (Int_t i=0;iAt(itrack); + AliITStrackMI * track = (AliITStrackMI*)array->At(itrack); if (track){ track->fChi2MIP[0] = GetNormalizedChi2(track, mode); if (track->fChi2MIP[0]At(index[0]); + besttrack = (AliITStrackMI*)array->At(index[0]); if (besttrack&&besttrack->fChi2MIP[0]fClIndex[i]>0){ @@ -2350,7 +2248,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo // calculate one more time with updated normalized errors for (Int_t i=0;iAt(itrack); + AliITStrackMI * track = (AliITStrackMI*)array->At(itrack); if (track){ track->fChi2MIP[0] = GetNormalizedChi2(track,mode); if (track->fChi2MIP[0]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++){ @@ -2380,7 +2278,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo Float_t minn = besttrack->GetNumberOfClusters()-3; Int_t accepted=0; for (Int_t i=0;iAt(index[i]); + AliITStrackMI * track = (AliITStrackMI*)array->At(index[i]); if (!track) continue; if (accepted>maxcut) break; track->fChi2MIP[0] = GetNormalizedChi2(track,mode); @@ -2420,7 +2318,7 @@ void AliITStrackerMI::SortTrackHypothesys(Int_t esdindex, Int_t maxcut, Int_t mo -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 @@ -2432,20 +2330,20 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 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;iAt(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(); @@ -2491,7 +2389,7 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 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; @@ -2522,7 +2420,7 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 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; @@ -2535,7 +2433,7 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 delete forwardtrack; Int_t accepted=0; for (Int_t i=0;iAt(i); + AliITStrackMI * track = (AliITStrackMI*)array->At(i); if (!track) continue; if (accepted>checkmax || track->fChi2MIP[3]>kMaxChi2PerCluster[3]*6. || (track->GetNumberOfClusters()GetNumberOfClusters()-1.)|| @@ -2551,16 +2449,16 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 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->fNDeadZonefChi2MIP[0]-besttrack->fChi2MIP[0]>0.0) continue; @@ -2629,7 +2527,7 @@ AliITStrackV2 * AliITStrackerMI::GetBestHypothesys(Int_t esdindex, AliITStrackV2 Bool_t cansign = kTRUE; for (Int_t itrack=0;itrackAt(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])){ @@ -2658,17 +2556,17 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) Int_t nentries = itsTracks.GetEntriesFast(); for (Int_t i=0;iGetEntriesFast()<=0) continue; // - AliITStrackV2* longtrack=0; + AliITStrackMI* longtrack=0; Float_t minn=0; Float_t maxchi2=1000; for (Int_t j=0;jGetEntriesFast();j++){ - AliITStrackV2* track = (AliITStrackV2*)array->At(j); + AliITStrackMI* track = (AliITStrackMI*)array->At(j); if (!track) continue; if (track->GetNumberOfClusters()+track->fNDeadZoneGetNumberOfClusters()+track->fNDeadZone>minn) maxchi2 = track->fChi2MIP[0]; @@ -2678,7 +2576,7 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) longtrack=track; break; } - AliITStrackV2 * besttrack = (AliITStrackV2*)array->At(0); + AliITStrackMI * besttrack = (AliITStrackMI*)array->At(0); if (!longtrack) {longtrack = besttrack;} else besttrack= longtrack; if (besttrack){ @@ -2717,7 +2615,7 @@ void AliITStrackerMI::GetBestHypothesysMIP(TObjArray &itsTracks) } -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. //-------------------------------------------------------------------- @@ -2750,7 +2648,7 @@ void AliITStrackerMI::CookLabel(AliITStrackV2 *track,Float_t wrong) const { -void AliITStrackerMI::CookdEdx(AliITStrackV2* track) +void AliITStrackerMI::CookdEdx(AliITStrackMI* track) { // // @@ -2808,7 +2706,7 @@ void AliITStrackerMI::MakeCoeficients(Int_t ntracks){ } -Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackV2* track, const AliITSclusterV2 *cluster,Int_t layer) +Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackMI* track, const AliITSclusterV2 *cluster,Int_t layer) { // // @@ -2837,7 +2735,7 @@ Double_t AliITStrackerMI::GetPredictedChi2MI(AliITStrackV2* track, const AliITSc } -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 { // // @@ -3101,14 +2999,14 @@ void AliITStrackerMI::SignDeltas( TObjArray *ClusterArray, Float_t vz) } -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)); } @@ -3128,7 +3026,7 @@ void AliITStrackerMI::FindV0(AliESD */*event*/) for (Int_t i=0;iAt(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); @@ -3136,11 +3034,11 @@ void AliITStrackerMI::FindV0(AliESD */*event*/) } } for (Int_t itrack0=0;itrack0fP4*track0->fP4>0) continue; //the same sign @@ -3186,12 +3084,12 @@ Double_t AliITStrackerMI::FindBestPair(Int_t esdtrack0, Int_t esdtrack1,AliITSR Int_t bestpair[2]; // for (Int_t itrack0=0;itrack0At(itrack0); + AliITStrackMI * track0 = (AliITStrackMI*)array0->At(itrack0); if (!track0) continue; if (track0->fXfX>criticalradius+5) continue; for (Int_t itrack1=0;itrack1At(itrack1); + AliITStrackMI * track1 = (AliITStrackMI*)array1->At(itrack1); if (!track1) continue; if (track1->fXfX>criticalradius+5) continue; diff --git a/ITS/AliITStrackerMI.h b/ITS/AliITStrackerMI.h index fc790f714fa..c58f7b1dc7c 100644 --- a/ITS/AliITStrackerMI.h +++ b/ITS/AliITStrackerMI.h @@ -5,18 +5,16 @@ //------------------------------------------------------------------------- // 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 #include "AliTracker.h" -#include "AliITStrackV2.h" +#include "AliITStrackMI.h" #include "AliITSclusterV2.h" -class AliITSclusterV2; class AliESD; class AliITSgeom; class TTree; @@ -24,7 +22,6 @@ class AliHelix; class AliV0vertex; - class AliITSRecV0Info: public TObject { friend class AliITStrackerMI; protected: @@ -61,11 +58,10 @@ public: {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); @@ -74,8 +70,8 @@ public: 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(){} @@ -197,47 +193,47 @@ protected: 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 @@ -249,7 +245,7 @@ protected: 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 }; @@ -302,7 +298,7 @@ inline void AliITStrackerMI::CookLabel(AliKalmanTrack *t,Float_t wrong) const { } } -inline Double_t AliITStrackerMI::NormalizedChi2(AliITStrackV2 * track, Int_t layer) +inline Double_t AliITStrackerMI::NormalizedChi2(AliITStrackMI * track, Int_t layer) { //-------------------------------------------------------------------- //get normalize chi2 diff --git a/ITS/AliITStrackerSA.cxx b/ITS/AliITStrackerSA.cxx index 608ddb4420d..b8fc3cdaced 100644 --- a/ITS/AliITStrackerSA.cxx +++ b/ITS/AliITStrackerSA.cxx @@ -658,7 +658,7 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert for(Int_t i=0;iGetNlayers();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;iGetNlayers();i++){ @@ -817,14 +817,14 @@ AliITStrackV2* AliITStrackerSA::FitTrack(AliITStrackSA* tr,Double_t *primaryVert //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 diff --git a/ITS/AliITStrackerV2.cxx b/ITS/AliITStrackerV2.cxx index 6d6a5335cf1..e57517be4ce 100644 --- a/ITS/AliITStrackerV2.cxx +++ b/ITS/AliITStrackerV2.cxx @@ -85,7 +85,7 @@ AliITStrackerV2::AliITStrackerV2(const AliITSgeom *geom) : AliTracker() { 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); @@ -116,7 +116,6 @@ Int_t AliITStrackerV2::LoadClusters(TTree *cTree) { branch->SetAddress(&clusters); Int_t j=0; - Int_t detector=0; for (Int_t i=0; iGetEntriesFast(); 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 } @@ -217,7 +200,7 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) { delete t; continue; } - if (TMath::Abs(t->GetD())>5) { + if (TMath::Abs(t->GetD())>4) { delete t; continue; } @@ -228,114 +211,53 @@ Int_t AliITStrackerV2::Clusters2Tracks(AliESD *event) { 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; iGetReconstructed()) 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(); fISetLabel(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; iGetLabel(); //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;ientryDelete(); - 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 @@ -383,7 +305,7 @@ Int_t AliITStrackerV2::PropagateBack(AliESD *event) { //fTrackToFollow.CookdEdx(); CookLabel(&fTrackToFollow,0.); //For comparison only fTrackToFollow.UpdateESDtrack(AliESDtrack::kITSout); - //UseClusters(&fTrackToFollow); + UseClusters(&fTrackToFollow); ntrk++; } delete t; @@ -410,7 +332,7 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) { 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 { @@ -431,14 +353,11 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) { 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(); @@ -457,7 +376,7 @@ Int_t AliITStrackerV2::RefitInward(AliESD *event) { 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()); @@ -551,13 +470,9 @@ void AliITStrackerV2::FollowProlongation() { 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"); @@ -572,49 +487,24 @@ void AliITStrackerV2::FollowProlongation() { 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() { @@ -638,6 +528,7 @@ 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]); @@ -657,23 +548,12 @@ Int_t AliITStrackerV2::TakeNextProlongation() { 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; @@ -690,15 +570,6 @@ Int_t AliITStrackerV2::TakeNextProlongation() { 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); } @@ -735,7 +606,6 @@ AliITStrackerV2::AliITSlayer::~AliITSlayer() { //-------------------------------------------------------------------- delete[] fDetectors; for (Int_t i=0; iGetZ() > fZmax) break; - // if (c->IsUsed()) continue; + if (c->IsUsed()) continue; const AliITSdetector &det=GetDetector(c->GetDetectorIndex()); Double_t y=fR*det.GetPhi() + c->GetY(); @@ -1138,18 +1000,6 @@ AliITStrackerV2::RefitAt(Double_t xx,AliITStrackV2 *t,const AliITStrackV2 *c) { 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 @@ -1164,540 +1014,3 @@ void AliITStrackerV2::UseClusters(const AliKalmanTrack *t, Int_t from) const { 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;itrackGetEntriesFast();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;iAt(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;iAt(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;itrackAt(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;itrackAt(itrack); - if (!track) continue; - sumall++; - sumz2+=track->GetSigmaZ2(); - sumy2+=track->GetSigmaY2(); - } - sumz2/=sumall; - sumy2/=sumall; - - Float_t dedxmismatch=1; - for (Int_t i=0;iAt(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;itrackAt(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;itrackAt(itrack); - if (!track) continue; - if (track->GetChi2MIP(1)>1000) continue; //not accepted - for (Int_t icluster=0;iclusterGetNumberOfClusters();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;iclusterGetNumberOfClusters();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)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;itrackAt(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;itrackAt(itrack); - if (!track) continue; - if (track->GetChi2MIP(1)>1000) continue; // track not accepted in previous iterration - for (Int_t icluster=0;iclusterGetNumberOfClusters();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;itrackAt(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;iclusterGetNumberOfClusters();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 (newchi2GetNumberOfClusters()<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;iclusterGetNumberOfClusters();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)SetLabel(original->GetLabel()); - CookLabel(besttrack,0.0); - - // - return besttrack; -} - diff --git a/ITS/AliITStrackerV2.h b/ITS/AliITStrackerV2.h index d3dafc00b8c..84dc746de31 100644 --- a/ITS/AliITStrackerV2.h +++ b/ITS/AliITStrackerV2.h @@ -8,9 +8,6 @@ // reads AliITSclusterV2 clusters and creates AliITStrackV2 tracks // Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch //------------------------------------------------------------------------- - -#include - #include "AliTracker.h" #include "AliITSrecoV2.h" #include "AliITStrackV2.h" @@ -45,7 +42,7 @@ public: 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;} @@ -57,21 +54,18 @@ public: }; 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 iGetLabel(); 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 diff --git a/ITS/ITSLinkDef.h b/ITS/ITSLinkDef.h index d5972569822..8058b89d664 100644 --- a/ITS/ITSLinkDef.h +++ b/ITS/ITSLinkDef.h @@ -143,6 +143,7 @@ #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+; diff --git a/ITS/libITS.pkg b/ITS/libITS.pkg index 67462a1960a..d641623c60f 100644 --- a/ITS/libITS.pkg +++ b/ITS/libITS.pkg @@ -63,6 +63,7 @@ SRCS = AliITS.cxx \ AliITSclusterV2.cxx \ AliITStrackV2.cxx \ AliITStrackerV2.cxx \ + AliITStrackMI.cxx \ AliITStrackerMI.cxx \ AliITSVertexer.cxx \ AliITSVertexerIons.cxx \