AliD0toKpiAnalysis::AliD0toKpiAnalysis() {
// Default constructor
- SetBz();
+ fBz=-9999;
SetPtCut();
Setd0Cut();
SetMassCut();
printf("AliD0toKpiAnalysis::FindCandidates(): Set B!\n");
return;
}
- AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
TString trkName("AliITStracksV2.root");
if(gSystem->AccessPathName(trkName.Data(),kFileExists)) {
printf("AliD0toKpiAnalysis::FindCandidatesESD(): Set B!\n");
return;
}
- AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
TString esdName("AliESDs.root");
if(gSystem->AccessPathName(esdName.Data(),kFileExists)) {
#include <TString.h>
#include <TNamed.h>
#include "AliESD.h"
+#include "AliMagF.h"
#include "AliITStrackV2.h"
//-----------------------------------------------------------------------------
void FindCandidatesESD(Int_t evFirst=0,Int_t evLast=0,
const Char_t *outName="AliD0toKpi.root");
void PrintStatus() const;
- void SetBz(Double_t bz=-9999.) { fBz=bz; }
+ void SetBz(const AliMagF *map) {
+ AliKalmanTrack::SetFieldMap(map); fBz=map->SolenoidField()/10.;
+ }
void SetVertexOnTheFly() { fVertexOnTheFly=kTRUE; }
void SetSimulation() { fSim=kTRUE; }
void SetOnlySignal() { fOnlySignal=kTRUE; }
if(!gSystem->AccessPathName("galice.root",kFileExists)) {
AliRunLoader *rl = AliRunLoader::Open("galice.root");
rl->LoadgAlice();
- field=(Double_t)(gAlice->Field()->SolenoidField())/10.;
- printf(" B = %3.1f T read from gAlice and set\n",field);
+ field=gAlice->Field();
+ Double_t bz=field->SolenoidField()/10.;
+ printf("B = %3.1f T read from gAlice and set\n",bz);
delete gAlice->GetRunLoader();
delete gAlice;
gAlice=0;
#include <TString.h>
#include <TTree.h>
+#include "AliAnalysis.h"
+#include "AliAODRun.h"
+
#include "AliAOD.h"
#include "AliAODParticle.h"
#include "AliAODParticleCut.h"
if (fITSTrackPoints)
{
Info("ReadESD","Magnetic Field is %f",mf);
- AliKalmanTrack::SetMagneticField(mf);
+ //AliKalmanTrack::SetMagneticField(mf);
}
AliStack* stack = 0x0;
AliRunLoader* rl = AliRunLoader::Open();
AliLoader* l = rl->GetLoader("TPCLoader");
rl->LoadgAlice();
- AliKalmanTrack::SetConvConst(100/0.299792458/0.2/rl->GetAliRun()->Field()->Factor());
+ AliKalmanTrack::SetFieldMap(rl->GetAliRun()->Field());
l->LoadTracks();
AliTPCtrack* t = new AliTPCtrack();
TBranch* b=l->TreeT()->GetBranch("tracks");
fEvent = event;
char filename[1024];
- AliKalmanTrack::SetConvConst(1000/0.299792458/AliL3Transform::GetSolenoidField());
+ //AliKalmanTrack::SetConvConst(1000/0.299792458/AliL3Transform::GetSolenoidField());
if(fMarian==kFALSE)
sprintf(filename,"%s/offline/AliTPCclusters.root",fPath);
else
fTracker = new AliTPCtracker(param);
else
fTracker = new AliTPCtrackerMI(param);
- fTracker->SetEventNumber(event);
+ //fTracker->SetEventNumber(event);
#ifdef asvversion
fTracker->LoadClusters();
#endif
fP3=xx[3];
fP4=xx[4];
+ SaveLocalConvConst();
+
//and covariance matrix
//For the moment estimate the covariance matrix numerically
Double_t xx1[5];
#include "AliRun.h"
#include "AliMagF.h"
#include "AliESD.h"
- #include "AliKalmanTrack.h"
+ #include "AliTracker.h"
#include "AliRunLoader.h"
#endif
return 3;
}
- AliKalmanTrack::SetConvConst(
- 1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField()
- );
-
+ // Magnetic field
+ AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
Double_t cuts[]={33., // max. allowed chi2
0.05, // min. allowed V0 impact parameter
0.008, // window around the Lambda mass
#include "AliITS.h"
#include "AliITSgeom.h"
- #include "AliITStrackV2.h"
#include "AliITSclusterV2.h"
#include "AliITSLoader.h"
#endif
while (esdTree->GetEvent(e)) {
cout<<endl<<endl<<"********* Processing event number: "<<e<<"*******\n";
- Float_t field=event->GetMagneticField();
- AliKalmanTrack::SetConvConst(1000/0.299792458/field);
-
Int_t nentr=event->GetNumberOfTracks();
allfound+=nentr;
AliESDtrack *esd=0;
Int_t cnt=0;
- Int_t pipe=0;
for (Int_t i=0; i<nentr; i++) {
AliESDtrack *t=event->GetTrack(i);
UInt_t status=t->GetStatus();
- UInt_t flags=AliESDtrack::kTPCin|AliESDtrack::kITSin;
if ((status&AliESDtrack::kITSrefit)==0) continue;
- if ((status&flags)==status) pipe=1;
-
Int_t lbl=t->GetLabel();
if (lab==TMath::Abs(lbl)) {
if (cnt==0) {esd=t; tlab=lbl;}
hfake->Fill(ptg);
}
- AliITStrackV2 track(*esd);
- if (pipe!=0) {
- track.PropagateTo(3.,0.0028,65.19);
- track.PropagateToVertex(); // This is not "exactly" the vertex
- }
-
- Double_t xv,par[5]; track.GetExternalParameters(xv,par);
- Float_t phi=TMath::ASin(par[2]) + track.GetAlpha();
+ Double_t xv,par[5]; esd->GetExternalParameters(xv,par);
+ Float_t phi=TMath::ASin(par[2]) + esd->GetAlpha();
if (phi<-TMath::Pi()) phi+=2*TMath::Pi();
if (phi>=TMath::Pi()) phi-=2*TMath::Pi();
Float_t lam=TMath::ATan(par[3]);
Float_t lamg=TMath::ATan2(ref->Pz(),ptg);
hl->Fill((lam - lamg)*1000.);
- Double_t d=10000*track.GetD(ref->X(),ref->Y());
- hmpt->Fill(d);
-
- Double_t z=10000*(track.GetZ()-ref->Z());
- hz->Fill(z);
+ Float_t d,z; esd->GetImpactParameters(d,z);
+ hmpt->Fill(10000*d);
+ hz->Fill(10000*(z-ref->Z()));
hpt->Fill((pt_1 - 1/ptg)/(1/ptg)*100.);
Float_t mom=1./(pt_1*TMath::Cos(lam));
- Float_t dedx=track.GetdEdx();
+ Float_t dedx=esd->GetITSsignal();
hep->Fill(mom,dedx,1.);
Int_t pdg=(Int_t)ref->GetLength(); //this is particle's PDG !
gAlice->GetEvent(evNumber); //modificato per gestire hbt
- AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+ AliKalmanTrack::SetFieldMap(gAlice->Field());
// cout<<" field = "<<gAlice->Field()->SolenoidField()<<endl;
}
//----------------------------------------------------------------------------
AliITSVertexerTracks::AliITSVertexerTracks(TFile *inFile,TFile *outFile,
- Double_t field,
+ const AliMagF *map,
Int_t fEv,Int_t lEv,
Double_t xStart,Double_t yStart) {
//
fOutFile = outFile;
SetFirstEvent(fEv);
SetLastEvent(lEv);
- SetField(field);
+ SetFieldMap(map);
SetVtxStart(xStart,yStart);
SetMinTracks();
fTrksToSkip = 0;
SetDebug();
}
//----------------------------------------------------------------------------
-AliITSVertexerTracks::AliITSVertexerTracks(Double_t field, TString fn,
+AliITSVertexerTracks::AliITSVertexerTracks(const AliMagF *map, TString fn,
Double_t xStart,Double_t yStart)
:AliITSVertexer(fn) {
//
//
fInFile = 0;
fOutFile = 0;
- SetField(field);
+ SetFieldMap(map);
SetVtxStart(xStart,yStart);
SetMinTracks();
fTrksToSkip = 0;
for(Int_t i=0; i<entr; i++) {
AliESDtrack *esdTrack = (AliESDtrack*)esdEvent->GetTrack(i);
- if(!(esdTrack->GetStatus()&AliESDtrack::kITSin))
+ if(!esdTrack->GetStatus()&AliESDtrack::kITSin)
{ delete esdTrack; continue; }
try {
itstrack = new AliITStrackV2(*esdTrack);
AliITSVertexerTracks();
// standard constructor
AliITSVertexerTracks(TFile *inFile,TFile *outFile,
- Double_t field=0.4,Int_t fEv=0,Int_t lEv=0,
+ const AliMagF *map,Int_t fEv=0,Int_t lEv=0,
Double_t xStart=0.,Double_t yStart=0.);
// alternative constructor
- AliITSVertexerTracks(Double_t field, TString fn,
+ AliITSVertexerTracks(const AliMagF *map, TString fn,
Double_t xStart=0,Double_t yStart=0);
// destructor
virtual ~AliITSVertexerTracks();
// computes the vertex for each event and stores it in the ESD
void FindVerticesESD();
virtual void PrintStatus() const;
- void SetField(Double_t field) const
- { AliKalmanTrack::SetConvConst(100./0.299792458/field); return; }
+ void SetFieldMap(const AliMagF *map)const{AliKalmanTrack::SetFieldMap(map);}
void SetMinTracks(Int_t n=2) { fMinTracks = n; return; }
void SetSkipTracks(Int_t n,Int_t *skipped);
void SetVtxStart(Double_t x=0,Double_t y=0)
#include "AliRun.h"
#include "AliRunLoader.h"
#include "AliMagF.h"
-#include "AliKalmanTrack.h"
#include "AliESDVertex.h"
#include "AliITSVertexer.h"
#include "AliITSVertexerTracks.h"
+#include "AliTracker.h"
//-------------------------------------
#endif
void AliITSVertexerTracksTest(Int_t evFirst=0,Int_t evLast=0,Bool_t esd=kTRUE,
rl->LoadgAlice();
AliMagF *fiel = (AliMagF*)gAlice->Field();
field=(Double_t)fiel->SolenoidField()/10.;
- AliKalmanTrack::SetConvConst(100/0.299792458/field);
printf(" B = %3.1f read from gAlice and set\n",field);
+
+ AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
} else {
printf(" File galice.root not found: default 0.4 T being used!\n");
}
rl->LoadgAlice();
AliMagF *fiel = (AliMagF*)gAlice->Field();
field=(Double_t)fiel->SolenoidField()/10.;
- AliKalmanTrack::SetConvConst(100/0.299792458/field);
printf(" B = %3.1f read from gAlice and set\n",field);
+
+ AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
+
+
} else {
printf(" File galice.root not found: default 0.4 T being used!\n");
}
Double_t x,p[5];
if (c) t.GetConstrainedExternalParameters(x,p);
else t.GetExternalParameters(x,p);
- fX=x; x=GetConvConst();
+ fX=x;
fP0=p[0];
- fP1=p[1];
+ fP1=p[1]; SaveLocalConvConst();
fP2=p[2];
- fP3=p[3];
+ fP3=p[3]; x=GetLocalConvConst();
fP4=p[4]/x;
//Conversion of the covariance matrix
// if (!Invariant()) throw "AliITStrackV2: conversion failed !\n";
for(Int_t i=0; i<4; i++) fdEdxSample[i]=0;
-
}
void AliITStrackV2::UpdateESDtrack(ULong_t flags) const {
// This function returns an external representation of the covriance matrix.
// (See comments in AliTPCtrack.h about external track representation)
//-------------------------------------------------------------------------
- Double_t a=GetConvConst();
+ Double_t a=GetLocalConvConst();
cc[0 ]=fC00;
cc[1 ]=fC10; cc[2 ]=fC11;
//------------------------------------------------------------------
Double_t x1=fX, x2=xk, dx=x2-x1;
Double_t f1=fP2, f2=f1 + fP4*dx;
- if (TMath::Abs(f2) >= 0.98) {
+ if (TMath::Abs(f2) >= 0.98) {
// MI change - don't propagate highly inclined tracks
// covariance matrix distorted
- // Int_t n=GetNumberOfClusters();
- // if (n>kWARN)
- // Warning("PropagateTo","Propagation failed !\n",n);
+ //Int_t n=GetNumberOfClusters();
+ //if (n>kWARN)
+ // Warning("PropagateTo","Propagation failed !\n",n);
return 0;
}
+ Double_t lcc=GetLocalConvConst();
// old position [SR, GSI, 17.02.2003]
Double_t oldX = fX, oldY = fP0, oldZ = fP1;
fX=x2;
+ //Change of the magnetic field *************
+ SaveLocalConvConst();
+ fP4*=lcc/GetLocalConvConst();
+
if (!CorrectForMaterial(d,x0)) return 0;
// Integrated Time [SR, GSI, 17.02.2003]
{
Double_t dx=xk-fX;
Double_t f1=fP2, f2=f1 + fP4*dx;
- if (TMath::Abs(f2) >= 0.98) {
+ if (TMath::Abs(f2) >= 0.98) {
// don't propagate highly inclined tracks MI
return 0;
}
- // if (TMath::Abs(f2) >= 0.9999) {
-// Int_t n=GetNumberOfClusters();
-// if (n>kWARN)
-// Warning("Propagate","Propagation failed (%d) !\n",n);
-// return 0;
-// }
+ // Int_t n=GetNumberOfClusters();
+ // if (n>kWARN)
+ // Warning("Propagate","Propagation failed (%d) !\n",n);
+ // return 0;
+ //}
+ Double_t lcc=GetLocalConvConst();
+
Double_t r1=TMath::Sqrt(1.- f1*f1), r2=TMath::Sqrt(1.- f2*f2);
-
+
fX=xk;
fP0 += dx*(f1+f2)/(r1+r2);
fP1 += dx*(f1+f2)/(f1*r2 + f2*r1)*fP3;
fP2 += dx*fP4;
+ //Change of the magnetic field *************
+ SaveLocalConvConst();
+ fP4*=lcc/GetLocalConvConst();
+
//f = F - 1
Double_t f02= dx/(r1*r1*r1);
Double_t GetSnp() const {return fP2;}
Double_t GetTgl() const {return fP3;}
Double_t GetC() const {return fP4;}
- Double_t
- Get1Pt() const { return (1e-9*TMath::Abs(fP4)/fP4 + fP4)*GetConvConst(); }
+ Double_t Get1Pt() const {
+ return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+ }
Double_t GetD(Double_t x=0, Double_t y=0) const;
Double_t GetZat(Double_t x=0) const;
Int_t Invariant() const;
protected:
+ void GetXYZ(Float_t r[3]) const;
+
Double_t fX; // X-coordinate of this track (reference plane)
Double_t fAlpha; // rotation angle
q *= TMath::Sqrt((1-s*s)/(1+t*t));
fdEdxSample[i]=q;
}
+
+inline void AliITStrackV2::GetXYZ(Float_t r[3]) const {
+ //---------------------------------------------------------------------
+ // Returns the position of the track in the global coord. system
+ //---------------------------------------------------------------------
+ Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+ r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
+}
+
#endif
#include "TStopwatch.h"
#include "AliRun.h"
- #include "AliKalmanTrack.h"
+ #include "AliTracker.h"
#include "AliMagF.h"
#include "AliESD.h"
#include "AliRunLoader.h"
return 3;
}
- AliKalmanTrack::SetConvConst(
- 1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField()
- );
+ // Magnetic field
+ AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
Double_t cuts[]={33, // max. allowed chi2
0.16,// min. allowed negative daughter's impact parameter
/* History of cvs commits:
*
* $Log$
+ * Revision 1.73 2005/05/28 14:19:05 schutz
+ * Compilation warnings fixed by T.P.
+ *
*/
//_________________________________________________________________________
track = fESD->GetTrack(iTrack);
if (track->IsPHOS())
continue ;
- if (!track->GetXYZAt(rPHOS,xyz))
+ if (!track->GetXYZAt(rPHOS, fESD->GetMagneticField(), xyz))
continue; //track coord on the cylinder of PHOS radius
if ((TMath::Abs(xyz[0])+TMath::Abs(xyz[1])+TMath::Abs(xyz[2]))<=0)
continue;
- if (!track->GetPxPyPzAt(rPHOS,pxyz))
+ if (!track->GetPxPyPzAt(rPHOS, fESD->GetMagneticField(), pxyz))
continue; // track momentum ibid.
vecDist = PropagateToPlane(xyz,pxyz,"CPV",cpvClu->GetPHOSMod());
// Info("GetDistanceInPHOSPlane","Track %d propagation to CPV = (%f,%f,%f)",
if (iClosestTrack != -1) {
track = fESD->GetTrack(iClosestTrack);
- if (track->GetPxPyPzAt(rPHOS,pxyz)) { // track momentum ibid.
+ if (track->GetPxPyPzAt(rPHOS, fESD->GetMagneticField(), pxyz)) { // track momentum ibid.
TVector3 vecCpvGlobal; // Global position of the CPV recpoint
AliPHOSGetter * gime = AliPHOSGetter::Instance() ;
const AliPHOSGeometry * geom = gime->PHOSGeometry() ;
AliError("HLT initialization failed!");
// Init magnetic field
- AliKalmanTrack::SetConvConst(
- 1000/0.299792458/AliL3Transform::GetSolenoidField()
- );
AliMagF* field = new AliMagFMaps("Maps","Maps", 2, 1., 10., AliMagFMaps::k5kG);
- AliTracker::SetFieldMap(field);
+ AliTracker::SetFieldMap(field,kTRUE);
fPtmin = 0.1*AliL3Transform::GetSolenoidField();
// Init ITS geometry
// printf("\n\n");
// printf("Pattern Recognition done for event %5i",0);
AliMagF * magf = gAlice->Field();
- AliTracker::SetFieldMap(magf);
+ AliTracker::SetFieldMap(magf,kTRUE);
for(Int_t iEvtN=0;iEvtN<GetLoader()->GetRunLoader()->GetNumberOfEvents();iEvtN++) {
GetLoader()->GetRunLoader()->GetEvent(iEvtN);
AliRICHTracker *tr = new AliRICHTracker();
}
//_______________________________________________________________________
-Bool_t AliESDtrack::GetExternalParametersAt(Double_t x, Double_t p[5]) const {
+Bool_t AliESDtrack::
+GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const {
//---------------------------------------------------------------------
- // This function returns external representation of the track parameters
- // at the position given by the first argument
+ // This function returns external track parameters extrapolated to
+ // the radial position "x" (cm) in the magnetic field "b" (kG)
//---------------------------------------------------------------------
+ Double_t convconst=0.299792458*b/1000.;
Double_t dx=x-fRx;
- Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+ Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
if (TMath::Abs(f2) >= 0.9999) return kFALSE;
}
//_______________________________________________________________________
-Double_t AliESDtrack::GetD(Double_t x, Double_t y) const {
+Double_t AliESDtrack::GetD(Double_t b, Double_t x, Double_t y) const {
//------------------------------------------------------------------
// This function calculates the transverse impact parameter
// with respect to a point with global coordinates (x,y)
+ // in the magnetic field "b" (kG)
//------------------------------------------------------------------
- Double_t rp4=fRp[4]/AliKalmanTrack::GetConvConst();
+ Double_t convconst=0.299792458*b/1000.;
+ Double_t rp4=fRp[4]*convconst;
Double_t xt=fRx, yt=fRp[0];
for (Int_t i=0; i<15; i++) cov[i]=fTc[i];
}
-Bool_t AliESDtrack::GetPxPyPzAt(Double_t x,Double_t *p) const {
+Bool_t AliESDtrack::GetPxPyPzAt(Double_t x, Double_t b, Double_t *p) const {
//---------------------------------------------------------------------
- // This function returns the global track momentum components
- // at the position "x" using the helix track approximation
+ // This function returns the global track momentum extrapolated to
+ // the radial position "x" (cm) in the magnetic field "b" (kG)
//---------------------------------------------------------------------
+ Double_t convconst=0.299792458*b/1000.;
p[0]=fRp[4];
- p[1]=fRp[2]+(x-fRx)*fRp[4]/AliKalmanTrack::GetConvConst();
+ p[1]=fRp[2]+(x-fRx)*fRp[4]*convconst;
p[2]=fRp[3];
return Local2GlobalMomentum(p,fRalpha);
}
-Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t *r) const {
+Bool_t AliESDtrack::GetXYZAt(Double_t x, Double_t b, Double_t *r) const {
//---------------------------------------------------------------------
- // This function returns the global track position
- // af the radius "x" using the helix track approximation
+ // This function returns the global track position extrapolated to
+ // the radial position "x" (cm) in the magnetic field "b" (kG)
//---------------------------------------------------------------------
+ Double_t convconst=0.299792458*b/1000.;
Double_t dx=x-fRx;
- Double_t f1=fRp[2], f2=f1 + dx*fRp[4]/AliKalmanTrack::GetConvConst();
+ Double_t f1=fRp[2], f2=f1 + dx*fRp[4]*convconst;
if (TMath::Abs(f2) >= 0.9999) return kFALSE;
if (good>(row1-row0)*0.5) density = Float_t(found)/Float_t(good);
return density;
}
+
//_______________________________________________________________________
void AliESDtrack::SetTPCpid(const Double_t *p) {
// Sets values for the probability of each particle type (in TPC)
- // normalize probabiluty to 1
- //
- //
-// Double_t sump=0;
-// for (Int_t i=0; i<AliPID::kSPECIES; i++) {
-// sump+=p[i];
-// }
-// for (Int_t i=0; i<AliPID::kSPECIES; i++) {
-// if (sump>0){
-// fTPCr[i]=p[i]/sump;
-// }
-// else{
-// fTPCr[i]=p[i];
-// }
-// }
- for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i] = p[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++) fTPCr[i]=p[i];
SetStatus(AliESDtrack::kTPCpid);
}
void GetExternalParameters(Double_t &x, Double_t p[5]) const;
void GetExternalCovariance(Double_t cov[15]) const;
- Bool_t GetExternalParametersAt(Double_t x, Double_t p[5]) const;
- Bool_t GetPxPyPzAt(Double_t x, Double_t p[3]) const;
- Bool_t GetXYZAt(Double_t x, Double_t r[3]) const;
+ Bool_t GetExternalParametersAt(Double_t x, Double_t b, Double_t p[5]) const;
+ Bool_t GetPxPyPzAt(Double_t x, Double_t b, Double_t p[3]) const;
+ Bool_t GetXYZAt(Double_t x, Double_t b, Double_t r[3]) const;
void GetImpactParameters(Float_t &xy,Float_t &z) const {xy=fD; z=fZ;}
- Double_t GetD(Double_t x=0, Double_t y=0) const; //calculate the transverse impact parameter w.r.t. (x,y)
+ Double_t GetD(Double_t b, Double_t x=0, Double_t y=0) const;
Double_t GetIntegratedLength() const {return fTrackLength;}
void GetIntegratedTimes(Double_t *times) const;
Double_t GetMass() const;
// TPC related track information
Float_t fTPCchi2; // chi2 in the TPC
Int_t fTPCncls; // number of clusters assigned in the TPC
- Int_t fTPCindex[180]; //! indices of the assigned TPC clusters
+ Int_t fTPCindex[180]; //! indices of the assigned TPC clusters
TBits fTPCClusterMap; // Map of clusters, one bit per padrow; 1 if has a cluster on given padrow
Float_t fTPCsignal; // detector's PID signal
Float_t fTPCr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
Float_t fTOFsignal; // detector's PID signal
Float_t fTOFr[AliPID::kSPECIES]; // "detector response probabilities" (for the PID)
Int_t fTOFLabel[3]; // TOF label
- Float_t fTOFInfo[10]; // TOF informations
+ Float_t fTOFInfo[10]; //! TOF informations
// PHOS related track information
Float_t fPHOSpos[3]; // position localised by PHOS in global coordinate system
//-------------------------------------------------------------------------
#include "AliKalmanTrack.h"
-#include "AliLog.h"
ClassImp(AliKalmanTrack)
-Double_t AliKalmanTrack::fgConvConst = 0;
+const AliMagF *AliKalmanTrack::fgkFieldMap=0;
+Double_t AliKalmanTrack::fgConvConst=0.;
//_______________________________________________________________________
AliKalmanTrack::AliKalmanTrack():
- TObject(),
fLab(-3141593),
fFakeRatio(0),
fChi2(0),
fMass(AliPID::ParticleMass(AliPID::kPion)),
fN(0),
+ fLocalConvConst(0),
fStartTimeIntegral(kFALSE),
fIntegratedLength(0)
{
//
// Default constructor
//
- if (fgConvConst==0) {
+ if (fgkFieldMap==0) {
AliFatal("The magnetic field has not been set!");
}
-
- for(Int_t i=0; i<5; i++) fIntegratedTime[i] = 0;
+
+ for(Int_t i=0; i<AliPID::kSPECIES; i++) fIntegratedTime[i] = 0;
}
//_______________________________________________________________________
fChi2(t.fChi2),
fMass(t.fMass),
fN(t.fN),
+ fLocalConvConst(t.fLocalConvConst),
fStartTimeIntegral(t.fStartTimeIntegral),
fIntegratedLength(t.fIntegratedLength)
{
//
// Copy constructor
//
- if (fgConvConst==0) {
+ if (fgkFieldMap==0) {
AliFatal("The magnetic field has not been set!");
}
-
- for (Int_t i=0; i<5; i++)
- fIntegratedTime[i] = t.fIntegratedTime[i];
+ for (Int_t i=0; i<AliPID::kSPECIES; i++)
+ fIntegratedTime[i] = t.fIntegratedTime[i];
}
//_______________________________________________________________________
printf("\n");
}
-static void External2Helix(const AliKalmanTrack *t, Double_t helix[6]) {
+void AliKalmanTrack::External2Helix(Double_t helix[6]) const {
//--------------------------------------------------------------------
// External track parameters -> helix parameters
//--------------------------------------------------------------------
Double_t alpha,x,cs,sn;
- t->GetExternalParameters(x,helix); alpha=t->GetAlpha();
+ GetExternalParameters(x,helix); alpha=GetAlpha();
cs=TMath::Cos(alpha); sn=TMath::Sin(alpha);
helix[5]=x*cs - helix[0]*sn; // x0
//helix[1]= // z0
helix[2]=TMath::ASin(helix[2]) + alpha; // phi0
//helix[3]= // tgl
- helix[4]=helix[4]/t->GetConvConst(); // C
+ helix[4]=helix[4]/GetLocalConvConst(); // C
}
static void Evaluate(const Double_t *h, Double_t t,
//dx2=dy2=dz2=1.;
- Double_t p1[8]; External2Helix(this,p1);
+ Double_t p1[8]; External2Helix(p1);
p1[6]=TMath::Sin(p1[2]); p1[7]=TMath::Cos(p1[2]);
- Double_t p2[8]; External2Helix(p,p2);
+ Double_t p2[8]; p->External2Helix(p2);
p2[6]=TMath::Sin(p2[2]); p2[7]=TMath::Cos(p2[2]);
return dca;
}
+
//-------------------------------------------------------------------------
#include <TObject.h>
+#include "AliLog.h"
#include "AliPID.h"
+#include "AliMagF.h"
class AliCluster;
Double_t GetMass() const {return fMass;}
Int_t GetNumberOfClusters() const {return fN;}
virtual Int_t GetClusterIndex(Int_t) const { //reserved for AliTracker
- Warning("GetClusterIndex(Int_t)","Method must be overloaded !\n");
+ AliWarning("Method must be overloaded !\n");
return 0;
}
virtual Double_t GetPIDsignal() const {
- Warning("GetPIDsignal()","Method must be overloaded !\n");
+ AliWarning("Method must be overloaded !\n");
return 0.;
}
virtual
Double_t PropagateToDCA(AliKalmanTrack *p, Double_t d=0., Double_t x0=0.);
virtual Double_t GetAlpha() const {
- Warning("GetAlpha()","Method must be overloaded !\n");
+ AliWarning("Method must be overloaded !\n");
return 0.;
}
virtual Double_t GetSigmaY2() const {
- Warning("GetSigmaY2()","Method must be overloaded !\n");
+ AliWarning("Method must be overloaded !\n");
return 0.;
}
virtual Double_t GetSigmaZ2() const {
- Warning("GetSigmaZ2()","Method must be overloaded !\n");
+ AliWarning("Method must be overloaded !\n");
return 0.;
}
virtual Int_t Compare(const TObject *) const {return 0;}
- virtual void GetExternalParameters(Double_t &/*xr*/, Double_t /*x*/[5]) const {}
- virtual void GetExternalCovariance(Double_t /*cov*/[15]) const {}
+ virtual void GetExternalParameters(Double_t&/*xr*/,Double_t/*x*/[5]) const=0;
+ virtual void GetExternalCovariance(Double_t /*cov*/[15]) const = 0;
- virtual Double_t GetPredictedChi2(const AliCluster *) const {return 0.;}
- virtual Int_t
- PropagateTo(Double_t /*xr*/, Double_t /*x0*/, Double_t /*rho*/) {return 0;}
- virtual Int_t PropagateToVertex(Double_t /*d*/=0., Double_t /*x0*/=0.)
- {return 0;}
- virtual Int_t
- Update(const AliCluster*, Double_t /*chi2*/, UInt_t) {return 0;}
+ virtual Double_t GetPredictedChi2(const AliCluster *) const = 0;
+ virtual Int_t PropagateTo(Double_t/*xr*/,Double_t/*x0*/,Double_t/*rho*/) = 0;
+ //virtual Int_t PropagateToVertex(Double_t /*d*/=0., Double_t /*x0*/=0.) = 0;
+ virtual Int_t Update(const AliCluster*, Double_t /*chi2*/, UInt_t) = 0;
- static void SetConvConst(Double_t cc) {fgConvConst=cc;}
- static Double_t GetConvConst() {return fgConvConst;}
+ static void SetFieldMap(const AliMagF *map) { fgkFieldMap=map; }
+ static const AliMagF *GetFieldMap() { return fgkFieldMap; }
- static void SetMagneticField(Double_t f) {// f - Magnetic field in T
- fgConvConst=100/0.299792458/f;
+ static void SetUniformFieldTracking() {
+ if (fgkFieldMap==0) {
+ printf("AliKalmanTrack: Field map has not been set !\n");
+ exit(1);
+ }
+ fgConvConst=1000/0.299792458/(fgkFieldMap->SolenoidField()+1e-13);
}
- Double_t GetMagneticField() const {return 100/0.299792458/fgConvConst;}
+ static void SetNonuniformFieldTracking() { fgConvConst=0.; }
+ static Double_t GetConvConst();
+
// Time integration (S.Radomski@gsi.de)
void StartTimeIntegral();
void SetIntegratedLength(Double_t l) {fIntegratedLength=l;}
void PrintTime() const;
protected:
+ virtual void GetXYZ(Float_t r[3]) const = 0;
+ void SaveLocalConvConst();
+ Double_t GetLocalConvConst() const;
+
+ void External2Helix(Double_t helix[6]) const;
+
void SetChi2(Double_t chi2) {fChi2=chi2;}
void SetMass(Double_t mass) {fMass=mass;}
void SetNumberOfClusters(Int_t n) {fN=n;}
Double_t fChi2; // total chi2 value for this track
Double_t fMass; // mass hypothesis
Int_t fN; // number of associated clusters
- private:
- static Double_t fgConvConst; //conversion constant cm -> GeV/c
+
+private:
+ static const AliMagF *fgkFieldMap;//pointer to the magnetic field map
+ static Double_t fgConvConst; //conversion "curvature(1/cm) -> pt(GeV/c)"
+ Double_t fLocalConvConst; //local conversion "curvature(1/cm) -> pt(GeV/c)"
// variables for time integration (S.Radomski@gsi.de)
Bool_t fStartTimeIntegral; // indicator wether integrate time
Double_t fIntegratedTime[AliPID::kSPECIES]; // integrated time
Double_t fIntegratedLength; // integrated length
- ClassDef(AliKalmanTrack,3) // Reconstructed track
+ ClassDef(AliKalmanTrack,4) // Reconstructed track
};
+inline Double_t AliKalmanTrack::GetConvConst() {
+//
+// For backward compatibility only !
+//
+ if (fgConvConst > 0 || fgConvConst < 0) return fgConvConst;
+ return 1000/0.299792458/(fgkFieldMap->SolenoidField()+1e-13);
+}
+
+inline void AliKalmanTrack::SaveLocalConvConst() {
+ //---------------------------------------------------------------------
+ // Saves local conversion constant "curvature (1/cm) -> pt (GeV/c)"
+ //---------------------------------------------------------------------
+ if (fgConvConst > 0 || fgConvConst < 0) return; //uniform field tracking
+ Float_t r[3]={0.,0.,0.}; GetXYZ(r);
+ Float_t b[3]; fgkFieldMap->Field(r,b);
+ fLocalConvConst=1000/0.299792458/(1e-13 - b[2]);
+}
+
+inline Double_t AliKalmanTrack::GetLocalConvConst() const {
+ //---------------------------------------------------------------------
+ // Returns conversion constant "curvature (1/cm) -> pt (GeV/c)"
+ //---------------------------------------------------------------------
+ if (fgConvConst > 0 || fgConvConst < 0) return fgConvConst; //uniform field tracking
+ return fLocalConvConst;
+}
+
#endif
// //
// rec.SetRunTracking("..."); //
// //
+// Uniform/nonuniform field tracking switches (default: uniform field) //
+// //
+// rec.SetUniformFieldTracking(); ( rec.SetNonuniformFieldTracking(); ) //
+// //
// The filling of additional ESD information can be steered by //
// //
// rec.SetFillESD("..."); //
#include "AliRawReaderFile.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
-#include "AliTracker.h"
#include "AliESD.h"
#include "AliESDVertex.h"
+#include "AliTracker.h"
#include "AliVertexer.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
TNamed(name, title),
fRunLocalReconstruction("ALL"),
+ fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
fRunHLTTracking(kFALSE),
fRunTracking("ALL"),
TNamed(rec),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
+ fUniformField(rec.fUniformField),
fRunVertexFinder(rec.fRunVertexFinder),
fRunHLTTracking(rec.fRunHLTTracking),
fRunTracking(rec.fRunTracking),
if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
if (fRunLoader->LoadgAlice() == 0) {
gAlice = fRunLoader->GetAliRun();
- AliTracker::SetFieldMap(gAlice->Field());
+ AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
}
}
if (!gAlice && !fRawReader) {
class AliRunLoader;
class AliRawReader;
class AliLoader;
-class AliVertexer;
class AliTracker;
+class AliVertexer;
class AliESD;
class TFile;
SetRunTracking(detectors);
SetFillESD(detectors);};
+ void SetUniformFieldTracking(){fUniformField=kTRUE;}
+ void SetNonuniformFieldTracking(){fUniformField=kFALSE;}
+
void SetStopOnError(Bool_t stopOnError)
{fStopOnError = stopOnError;}
void SetCheckPointLevel(Int_t checkPointLevel)
void WriteESD(AliESD* esd, const char* recStep) const;
TString fRunLocalReconstruction; // run the local reconstruction for these detectors
+ Bool_t fUniformField; // uniform field tracking flag
Bool_t fRunVertexFinder; // run the vertex finder
Bool_t fRunHLTTracking; // run the HLT tracking
TString fRunTracking; // run the tracking for these detectors
AliVertexer* fVertexer; //! vertexer for ITS
AliTracker* fTracker[fgkNDetectors]; //! trackers
- ClassDef(AliReconstruction, 4) // class for running the reconstruction
+ ClassDef(AliReconstruction, 5) // class for running the reconstruction
};
#endif
#include <TMath.h>
#include "AliTracker.h"
-#include "AliCluster.h"
#include "AliKalmanTrack.h"
+#include "AliCluster.h"
#include "AliLog.h"
#include "AliRun.h"
#include "AliMagF.h"
ClassImp(AliTracker)
AliTracker::AliTracker():
- fEventN(0),
- fStoreBarrel(1),
fX(0),
fY(0),
fZ(0),
if (!fgkFieldMap) AliWarning("Field map is not set. Call AliTracker::SetFieldMap before creating a tracker!");
}
-void AliTracker::SetFieldMap(const AliMagF* map) {
+void AliTracker::SetFieldMap(const AliMagF* map, Bool_t uni) {
//--------------------------------------------------------------------
//This passes the field map to the reconstruction.
//--------------------------------------------------------------------
if (map==0) AliFatalClass("Can't access the field map !");
- AliKalmanTrack::SetConvConst(1000/0.299792458/(map->SolenoidField()+1e-13));
+ AliKalmanTrack::SetFieldMap(map);
+ if (uni) AliKalmanTrack::SetUniformFieldTracking();
fgkFieldMap=map;
}
// Origin: Iouri Belikov, CERN, Jouri.Belikov@cern.ch
//-------------------------------------------------------------------------
#include <TObject.h>
-//#include "TError.h"
-class AliKalmanTrack;
class AliCluster;
class TTree;
+class AliKalmanTrack;
class AliESD;
class AliMagF;
fX=xyz[0]; fY=xyz[1]; fZ=xyz[2];
if (ers) { fSigmaX=ers[0]; fSigmaY=ers[1]; fSigmaZ=ers[2]; }
}
- void SetEventNumber(Int_t ev) { fEventN=ev; }
//protected:
virtual Int_t LoadClusters(TTree *)=0;
Double_t GetSigmaX() const {return fSigmaX;}
Double_t GetSigmaY() const {return fSigmaY;}
Double_t GetSigmaZ() const {return fSigmaZ;}
- Int_t GetEventNumber() const {return fEventN;}
- static void SetFieldMap(const AliMagF* map);
+ static void SetFieldMap(const AliMagF* map, Bool_t uni);
static const AliMagF *GetFieldMap() {return fgkFieldMap;}
-
- Int_t IsStoringBarrel() const {return fStoreBarrel;}
- void SetStoreBarrel(Int_t s) {fStoreBarrel = s;}
private:
AliTracker & operator=(const AliTracker & atr);
static const AliMagF *fgkFieldMap; //field map
- Int_t fEventN;//event number
-
- Int_t fStoreBarrel; //Store Barrel information
Double_t fX; //X-coordinate of the primary vertex
Double_t fY; //Y-coordinate of the primary vertex
Double_t fSigmaY; // error of the primary vertex position in Y
Double_t fSigmaZ; // error of the primary vertex position in Z
- ClassDef(AliTracker,1) //abstract tracker
+ ClassDef(AliTracker,2) //abstract tracker
};
#endif
fX=x;
- x = GetConvConst();
-
fY=p[0];
- fZ=p[1];
- fT=p[3];
+ fZ=p[1]; SaveLocalConvConst();
+ fT=p[3]; x=GetLocalConvConst();
fC=p[4]/x;
fE=fC*fX - p[2];
//
// This function returns external representation of the covriance matrix.
//
- Double_t a=GetConvConst();
+ Double_t a=GetLocalConvConst();
Double_t c22=fX*fX*fCcc-2*fX*fCce+fCee;
Double_t c32=fX*fCct-fCte;
Double_t c20=fX*fCcy-fCey, c21=fX*fCcz-fCez, c42=fX*fCcc-fCce;
if (TMath::Abs(fC*xk - fE) >= 0.90000) {
return 0;
}
+ Double_t lcc=GetLocalConvConst();
// track Length measurement [SR, GSI, 17.02.2003]
fX=x2;
+ //Change of the magnetic field *************
+ SaveLocalConvConst();
+ cc=fC;
+ fC*=lcc/GetLocalConvConst();
+ fE+=fX*(fC-cc);
+
//Multiple scattering ******************
Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
Double_t GetSigmaY2() const {return fCyy;}
Double_t GetSigmaZ2() const {return fCzz;}
- Double_t Get1Pt() const {return (1e-9*TMath::Abs(fC)/fC + fC)*GetConvConst();}
+ Double_t Get1Pt() const {
+ return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
+ }
Double_t GetP() const {
return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
}
void ResetCovariance(Float_t mult);
Int_t Rotate(Double_t angle);
-
-
protected:
-
+ void GetXYZ(Float_t r[3]) const;
+ Int_t Update(const AliCluster */*c*/, Double_t /*chi2*/, UInt_t /*idx*/) {
+ return 0;
+ }
+ Double_t GetPredictedChi2(const AliCluster */*c*/) const {return 0.;}
+
Int_t fSeedInd; // ESD seed track index
Int_t fSeedLab; // track label taken from seeding
Double_t fAlpha; // rotation angle
};
+inline void AliTOFtrack::GetXYZ(Float_t r[3]) const {
+ //---------------------------------------------------------------------
+ // Returns the position of the track in the global coord. system
+ //---------------------------------------------------------------------
+ Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+ r[0]=fX*cs - fY*sn; r[1]=fX*sn + fY*cs; r[2]=fZ;
+}
+
#endif
// if(gAlice)delete gAlice; COMMENTED BECAUSE OF A BUG (IN COMPILED MODE)
gAlice = (AliRun*)inkin->Get("gAlice");
cout<<"AliRun object found on file "<<gAlice<<endl;
- AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+ AliKalmanTrack::SetFieldMap(gAlice->Field());
inkin->Close();
/*
delete gAlice; COMMENTED BECAUSE OF A BUG IN COMPILED MODE
cerr<<"Error occured while l"<<endl;
return 1;
}
- AliKalmanTrack::SetConvConst(1000/0.299792458/rl->GetAliRun()->Field()->SolenoidField());
+ AliKalmanTrack::SetFieldMap(rl->GetAliRun()->Field());
rl->CdGAFile();
cout<<"TPCtrack dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
return pcode?pcode:211;
}
-
+/*
//-----------------------------------------------------------
Int_t AliTPCPid::GetPcode(AliKalmanTrack *track)
{
cout<<"ITS V2 dedx,mom,pcode="<<dedx<<","<<mom<<","<<pcode<<endl;
return pcode?pcode:211;
}
-
+*/
//-----------------------------------------------------------
Int_t AliTPCPid::GetPcode(Float_t q,Float_t pm)
{
Int_t GetPcode(TClonesArray* ,Float_t) const;
Int_t GetPcode(Float_t q,Float_t pm);
Int_t GetPcode(AliTPCtrack*track);
-// Int_t GetPcode(AliITSIOTrack*);
- Int_t GetPcode(AliKalmanTrack* track);
+ //Int_t GetPcode(AliKalmanTrack* track);
void SetCut(Int_t n, Float_t pm, Float_t pilo, Float_t pihi,
Float_t klo, Float_t khi, Float_t plo,
Float_t phi);
gAlice = (AliRun*)inkin->Get("gAlice");
cout<<"AliRun object found on file "<<gAlice<<endl;
cout<<"!!!! field ="<<gAlice->Field()->SolenoidField()<<endl;
-AliKalmanTrack::SetConvConst(1000/0.299792458/gAlice->Field()->SolenoidField());
+AliKalmanTrack::SetFieldMap(gAlice->Field());
inkin->Close();
cout<<" Convconst="<<AliKalmanTrack::GetConvConst()<<endl;
///////////////////////////////////////
fX = fP0 = fP1 = fP2 = fP3 = fP3 = fP4 = 0.0;
fAlpha = fdEdx = 0.0;
fNumber = 0; // [SR, 01.04.2003]
- for (Int_t i=0; i<3;i++) {fKinkIndexes[i]=0; fV0Indexes[i]=0;}
+ for (Int_t i=0; i<3;i++) fKinkIndexes[i]=0;
}
//_________________________________________________________________________
fP0=xx[0]; fP1=xx[1]; fP2=xx[2]; fP3=xx[3]; fP4=xx[4];
+ SaveLocalConvConst();
+
fC00=cc[0];
fC10=cc[1]; fC11=cc[2];
fC20=cc[3]; fC21=cc[4]; fC22=cc[5];
Double_t x,p[5]; t.GetExternalParameters(x,p);
Double_t c[15]; t.GetExternalCovariance(c);
- fX=x; x=GetConvConst();
+ fX=x;
fP0=p[0];
- fP1=p[1];
- fP3=p[3];
+ fP1=p[1]; SaveLocalConvConst();
+ fP3=p[3]; x=GetLocalConvConst();
fP4=p[4]/x;
fP2=fP4*fX - p[2];
//_____________________________________________________________________________
void AliTPCtrack::GetExternalCovariance(Double_t cc[15]) const {
- //-------------------------------------------------------------------------
+ //-------------------------------------------------------------------------
// This function returns an external representation of the covriance matrix.
// (See comments in AliTPCtrack.h about external track representation)
//-------------------------------------------------------------------------
- Double_t a=GetConvConst();
+ Double_t a=GetLocalConvConst();
Double_t c22=fX*fX*fC44-2*fX*fC42+fC22;
Double_t c32=fX*fC43-fC32;
//if (n>4) cerr<<n<<" AliTPCtrack warning: Propagation failed !\n";
return 0;
}
-
+ Double_t lcc=GetLocalConvConst();
+
// old position for time [SR, GSI 17.02.2003]
Double_t oldX = fX;
Double_t oldY = fP0;
fX=x2;
- //Multiple scattering******************
+ //Change of the magnetic field *************
+ SaveLocalConvConst();
+ cc=fP4;
+ fP4*=lcc/GetLocalConvConst();
+ fP2+=fX*(fP4-cc);
+
+ //Multiple scattering ******************
Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fP0)*(y1-fP0)+(z1-fP1)*(z1-fP1));
Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
Double_t beta2=p2/(p2 + GetMass()*GetMass());
fC43 += dc43;
fC44 += dc44;
*/
- //Energy losses************************
+ //Energy losses ************************
Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2)) - beta2)*d*rho;
if (x1 < x2) dE=-dE;
cc=fP4;
Double_t GetY() const {return fP0;}
Double_t GetZ() const {return fP1;}
Double_t GetSnp() const {return fX*fP4 - fP2;}
- Double_t
- Get1Pt() const { return (1e-9*TMath::Abs(fP4)/fP4 + fP4)*GetConvConst(); }
+ Double_t Get1Pt() const {
+ return (TMath::Sign(1e-9,fP4) + fP4)*GetLocalConvConst();
+ }
Double_t GetTgl() const {return fP3;}
Double_t GetSigmaY2() const {return fC00;}
Int_t GetV0Index(Int_t i) const{ return fV0Indexes[i];}
Int_t* GetV0Indexes() { return fV0Indexes;}
protected:
+ void GetXYZ(Float_t r[3]) const;
+
Double_t fX; // X-coordinate of this track (reference plane)
Double_t fAlpha; // Rotation angle the local (TPC sector)
// coordinate system and the global ALICE one.
x[0]=GetY(); x[1]=GetZ(); x[2]=GetSnp(); x[3]=GetTgl(); x[4]=Get1Pt();
}
+inline void AliTPCtrack::GetXYZ(Float_t r[3]) const {
+ //---------------------------------------------------------------------
+ // Returns the position of the track in the global coord. system
+ //---------------------------------------------------------------------
+ Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+ r[0]=fX*cs - fP0*sn; r[1]=fX*sn + fP0*cs; r[2]=fP1;
+}
+
+
#endif
tpc->SetParam(digp);
// Set the conversion constant between curvature and Pt
- AliKalmanTrack::SetConvConst(100/0.299792458/fBz);
+ AliKalmanTrack::SetFieldMap(fiel);
TParticle *part=0;
AliTPCseedGeant *seed=0;
fX=xref;
fY=xx[0]; fZ=xx[1]; fE=xx[2]; fT=xx[3]; fC=xx[4];
+
+ SaveLocalConvConst();
fCyy=cc[0];
fCzy=cc[1]; fCzz=cc[2];
fIndex[i] = 0;
fIndexBackup[i] = 0; //MI backup indexes
}
- for (Int_t i=0;i<6;i++){
- fTracklets[i]=t.fTracklets[i];
- }
}
//_____________________________________________________________________________
fX=x;
- x = GetConvConst();
-
fY=p[0];
fZ=p[1];
- fT=p[3];
+ fT=p[3]; x=GetLocalConvConst();
fC=p[4]/x;
fE=fC*fX - p[2];
fX=x;
- x = GetConvConst();
-
fY=p[0];
- fZ=p[1];
- fT=p[3];
+ fZ=p[1]; SaveLocalConvConst();
+ fT=p[3]; x=GetLocalConvConst();
fC=p[4]/x;
fE=fC*fX - p[2];
Float_t AliTRDtrack::StatusForTOF()
{
Int_t status=0;
- if (fNRotate>2) return -1; // sure it's stopped
if (GetNumberOfClusters()<20) return 0; //
-
- //comp->fTree->SetAlias("nlast2","track.fTracklets[5].fNFound+track.fTracklets[4].fNFound");
- //comp->fTree->SetAlias("goldtrack","abs((track.fTracklets[5].fP1+track.fTracklets[4].fP1))<0.5&&nlast2>14");
- Int_t nlast2 = fTracklets[5].fNFound+fTracklets[4].fNFound;
- if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.3 &&nlast2>20) return 3;
- if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.3 &&nlast2>14) return 2;
- if (TMath::Abs((fTracklets[5].fP1+fTracklets[4].fP1))<0.5 &&nlast2>14) return 1;
+ if (fN>110&&fChi2/(Float_t(fN))<3) return 3; //gold
+ if (fNLast>30&&fChi2Last/(Float_t(fNLast))<3) return 3; //gold
+ if (fNLast>20&&fChi2Last/(Float_t(fNLast))<2) return 3; //gold
+ if (fNLast/(fNExpectedLast+3.)>0.8 && fChi2Last/Float_t(fNLast)<5&&fNLast>20) return 2; //silber
+ if (fNLast>5 &&((fNLast+1.)/(fNExpectedLast+1.))>0.8&&fChi2Last/(fNLast-5.)<6) return 1;
+ //
return status;
}
//
// This function returns external representation of the covriance matrix.
//
- Double_t a=GetConvConst();
+ Double_t a=GetLocalConvConst();
Double_t c22=fX*fX*fCcc-2*fX*fCce+fCee;
Double_t c32=fX*fCct-fCte;
Float_t sorted[kMAX_CLUSTERS_PER_TRACK];
for (i=0; i < nc; i++) {
- sorted[i]=TMath::Abs(fdQdl[i]);
+ sorted[i]=fdQdl[i];
}
- Int_t * index = new Int_t[nc];
- TMath::Sort(nc, sorted, index,kFALSE);
-
+ /*
+ Int_t swap;
+
+ do {
+ swap=0;
+ for (i=0; i<nc-1; i++) {
+ if (sorted[i]<=sorted[i+1]) continue;
+ Float_t tmp=sorted[i];
+ sorted[i]=sorted[i+1]; sorted[i+1]=tmp;
+ swap++;
+ }
+ } while (swap);
+ */
Int_t nl=Int_t(low*nc), nu=Int_t(up*nc);
Float_t dedx=0;
- for (i=nl; i<=nu; i++) dedx += sorted[index[i]];
- dedx /= (nu-nl+1);
+ //for (i=nl; i<=nu; i++) dedx += sorted[i];
+ //dedx /= (nu-nl+1);
+ for (i=0; i<nc; i++) dedx += sorted[i]; // ADDED by PS
+ if((nu-nl)) dedx /= (nu-nl); // ADDED by PS
SetdEdx(dedx);
}
// << GetPt() << "\t" << GetLabel() << "\t" << GetMass() << endl;
return 0;
}
+ Double_t lcc=GetLocalConvConst();
// track Length measurement [SR, GSI, 17.02.2003]
Double_t oldX = fX, oldY = fY, oldZ = fZ;
fX=x2;
+ //Change of the magnetic field *************
+ SaveLocalConvConst();
+ cc=fC;
+ fC*=lcc/GetLocalConvConst();
+ fE+=fX*(fC-cc);
+
//Multiple scattering ******************
Double_t d=sqrt((x1-fX)*(x1-fX)+(y1-fY)*(y1-fY)+(z1-fZ)*(z1-fZ));
Double_t p2=(1.+ GetTgl()*GetTgl())/(Get1Pt()*Get1Pt());
Double_t beta2=p2/(p2 + GetMass()*GetMass());
Double_t theta2=14.1*14.1/(beta2*p2*1e6)*d/x0*rho;
- theta2*= 3.; // magic const - to normalize pools - waiting for geo manager
- if (p2>2.) beta2*= 0.4; // magic const - theta2 for relativistic particles
- // - not valid for electrons
+
Double_t ey=fC*fX - fE, ez=fT;
Double_t xz=fC*ez, zz1=ez*ez+1, xy=fE+ey;
//Energy losses************************
if((5940*beta2/(1-beta2+1e-10) - beta2) < 0) return 0;
- Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
- dE *= 1.2; // magic const - to normalize pools - waiting for geo manager
+ Double_t dE=0.153e-3/beta2*(log(5940*beta2/(1-beta2+1e-10)) - beta2)*d*rho;
if (x1 < x2) dE=-dE;
cc=fC;
fC*=(1.- sqrt(p2+GetMass()*GetMass())/p2*dE);
fE+=fX*(fC-cc);
- //
- Double_t deltac = fC-cc;
- fCcc += 4*deltac*deltac; // fluctuation of energy losses
- fCee += 4*fX*fX*deltac*deltac; // local angle unchanged
- fCce += 4*fX*deltac*deltac; // correlation 1
- //
+
// track time measurement [SR, GSI 17.02.2002]
if (x1 < x2)
if (IsStartedTimeIntegral()) {
}
Double_t tangent = TMath::Sqrt(tangent2);
if ((fC*fX-fE)<0) tangent*=-1;
- Double_t errsys =(0.025*0.025*20)*(1+tangent2); //systematic error part
+ // Double_t correction = 0*plane;
+ Double_t errang = tangent2*0.04; //
+ Double_t errsys =0.025*0.025*20; //systematic error part
+ Float_t extend =1;
+ if (c->GetNPads()==4) extend=2;
+ //if (c->GetNPads()==5) extend=3;
+ //if (c->GetNPads()==6) extend=3;
+ //if (c->GetQ()<15) return 1;
/*
if (corrector!=0){
}
*/
//
- Double_t r00=(c->GetSigmaY2()+errsys), r01=0., r11=c->GetSigmaZ2()*10000.;
+ // Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12.);
+
+ Double_t r00=(c->GetSigmaY2() +errang+errsys)*extend, r01=0., r11=c->GetSigmaZ2()*10000.;
r00+=fCyy; r01+=fCzy; r11+=fCzz;
Double_t det=r00*r11 - r01*r01;
Double_t tmp=r00; r00=r11/det; r11=tmp/det; r01=-r01/det;
fC = cur;
}
else {
- // Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
+ Double_t padlength = TMath::Sqrt(c->GetSigmaZ2()*12);
Double_t xu_factor = 1000.; // empirical factor set by C.Xu
// in the first tilt version
dy=c->GetY() - fY; dz=c->GetZ() - fZ;
+ //dy=dy+h01*dz+correction;
Double_t tiltdz = dz;
+ if (TMath::Abs(tiltdz)>padlength/2.) {
+ tiltdz = TMath::Sign(padlength/2,dz);
+ }
+ // dy=dy+h01*dz;
dy=dy+h01*tiltdz;
- Double_t s00 = c->GetSigmaY2()+errsys; // error pad
+ Double_t add=0;
+ if (TMath::Abs(dz)>padlength/2.){
+ //Double_t dy2 = c->GetY() - fY;
+ //Double_t sign = (dz>0) ? -1.: 1.;
+ //dy2-=h01*sign*padlength/2.;
+ //dy = dy2;
+ add =1;
+ }
+ Double_t s00 = (c->GetSigmaY2()+errang)*extend+errsys+add; // error pad
Double_t s11 = c->GetSigmaZ2()*xu_factor; // error pad-row
//
r00 = fCyy + 2*fCzy*h01 + fCzz*h01*h01+s00;
-
-
//_____________________________________________________________________________
Int_t AliTRDtrack::UpdateMI(const AliTRDtracklet &tracklet)
{
}
+
//_____________________________________________________________________________
Int_t AliTRDtrack::Rotate(Double_t alpha)
{
// return 0 if not exist
Double_t c1=fC*fX - fE;
- if (TMath::Abs(c1)>0.9) return 0;
+ if (TMath::Abs(c1)>1.) return 0;
Double_t r1=TMath::Sqrt(1.- c1*c1);
Double_t c2=fC*xk - fE;
- if (TMath::Abs(c2)>0.9) return 0;
+ if (TMath::Abs(c2)>1.) return 0;
Double_t r2=TMath::Sqrt(1.- c2*c2);
y =fY + (xk-fX)*(c1+c2)/(r1+r2);
z =fZ + (xk-fX)*(c1+c2)/(c1*r2 + c2*r1)*fT;
};
-
-
class AliTRDtrack : public AliKalmanTrack {
// Represents reconstructed TRD track
Double_t GetLikelihoodElectron() const { return fLhElectron; };
- Double_t Get1Pt() const {return (1e-9*TMath::Abs(fC)/fC + fC)*GetConvConst(); }
+ Double_t Get1Pt() const {
+ return (TMath::Sign(1e-9,fC) + fC)*GetLocalConvConst();
+ }
Double_t GetP() const {
return TMath::Abs(GetPt())*sqrt(1.+GetTgl()*GetTgl());
}
protected:
+ void GetXYZ(Float_t r[3]) const;
+
+ Double_t GetPredictedChi2(const AliCluster*/*c*/) const {return 0.;}
+ Int_t Update(const AliCluster*/*c*/, Double_t /*chi2*/, UInt_t /*i*/) {
+ return 0;
+ }
Int_t fSeedLab; // track label taken from seeding
Float_t fdEdx; // dE/dx
ClassDef(AliTRDtrack,2) // TRD reconstructed tracks
};
+inline void AliTRDtrack::GetXYZ(Float_t r[3]) const {
+ //---------------------------------------------------------------------
+ // Returns the position of the track in the global coord. system
+ //---------------------------------------------------------------------
+ Double_t cs=TMath::Cos(fAlpha), sn=TMath::Sin(fAlpha);
+ r[0]=fX*cs - fY*sn; r[1]=fX*sn + fY*cs; r[2]=fZ;
+}
#endif
#include "AliHeader.h"
#include "AliGenEventHeader.h"
#include "AliTPCtrack.h"
+#include "AliTracker.h"
#endif
copyGeneralESDInfo(esdOut,esdNew);
- // Needed by the TPC track
- AliKalmanTrack::SetConvConst(1000/0.299792458/esdOut->GetMagneticField());
-
// Tracks
Int_t nrec = esdOut->GetNumberOfTracks();
for(Int_t irec=0; irec<nrec; irec++) {
runLoader->LoadgAlice();
gAlice = runLoader->GetAliRun();
+ // Magnetic field
+ AliTracker::SetFieldMap(gAlice->Field(),1); // 1 means uniform magnetic field
+
// Now load kinematics and event header
runLoader->LoadKinematics();
runLoader->LoadHeader();
git://git.uio.no / u/mrichter/AliRoot.git / commitdiff