// Markus.Oldenburg@cern.ch
//-------------------------------------------------------------------------
+#include <TVector3.h>
#include "AliLog.h"
#include "AliExternalTrackParam.h"
#include "AliVVertex.h"
+#include "AliDetectorPID.h"
+#include "AliAODEvent.h"
+#include "AliAODHMPIDrings.h"
+#include "AliTOFHeader.h"
+
#include "AliAODTrack.h"
ClassImp(AliAODTrack)
fRAtAbsorberEnd(0.),
fChi2perNDF(-999.),
fChi2MatchTrigger(0.),
+ fPID(0),
fFlags(0),
fLabel(-999),
+ fTOFLabel(),
+ fTrackLength(0),
fITSMuonClusterMap(0),
+ fMUONtrigHitsMapTrg(0),
+ fMUONtrigHitsMapTrk(0),
fFilterMap(0),
+ fTPCFitMap(),
fTPCClusterMap(),
fTPCSharedMap(),
fTPCnclsF(0),
+ fTPCNCrossedRows(0),
fID(-999),
fCharge(-99),
fType(kUndef),
+ fPIDForTracking(AliPID::kPion),
fCaloIndex(kEMCALNoMatch),
fCovMatrix(NULL),
fDetPid(NULL),
- fProdVertex(NULL)
+ fDetectorPID(NULL),
+ fProdVertex(NULL),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fIsMuonGlobalTrack(kFALSE), // AU
+ fTPCsignalTuned(0),
+ fTOFsignalTuned(99999),
+ fMFTClusterPattern(0), // AU
+ fAODEvent(NULL)
{
// default constructor
SetPosition((Float_t*)NULL);
SetXYAtDCA(-999., -999.);
SetPxPyPzAtDCA(-999., -999., -999.);
- SetPID((Float_t*)NULL);
+ for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = -1;}
}
//______________________________________________________________________________
Double_t covMatrix[21],
Short_t charge,
UChar_t itsClusMap,
- Double_t pid[10],
AliAODVertex *prodVertex,
Bool_t usedForVtxFit,
Bool_t usedForPrimVtxFit,
fRAtAbsorberEnd(0.),
fChi2perNDF(chi2perNDF),
fChi2MatchTrigger(0.),
+ fPID(0),
fFlags(0),
fLabel(label),
+ fTOFLabel(),
+ fTrackLength(0),
fITSMuonClusterMap(0),
+ fMUONtrigHitsMapTrg(0),
+ fMUONtrigHitsMapTrk(0),
fFilterMap(selectInfo),
+ fTPCFitMap(),
fTPCClusterMap(),
fTPCSharedMap(),
fTPCnclsF(0),
+ fTPCNCrossedRows(0),
fID(id),
fCharge(charge),
fType(ttype),
+ fPIDForTracking(AliPID::kPion),
fCaloIndex(kEMCALNoMatch),
fCovMatrix(NULL),
fDetPid(NULL),
- fProdVertex(prodVertex)
+ fDetectorPID(NULL),
+ fProdVertex(prodVertex),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fIsMuonGlobalTrack(kFALSE), // AU
+ fTPCsignalTuned(0),
+ fTOFsignalTuned(99999),
+ fMFTClusterPattern(0), // AU
+ fAODEvent(NULL)
{
// constructor
SetUsedForVtxFit(usedForVtxFit);
SetUsedForPrimVtxFit(usedForPrimVtxFit);
if(covMatrix) SetCovMatrix(covMatrix);
- SetPID(pid);
SetITSClusterMap(itsClusMap);
+ for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
}
//______________________________________________________________________________
Float_t covMatrix[21],
Short_t charge,
UChar_t itsClusMap,
- Float_t pid[10],
AliAODVertex *prodVertex,
Bool_t usedForVtxFit,
Bool_t usedForPrimVtxFit,
AODTrk_t ttype,
UInt_t selectInfo,
- Float_t chi2perNDF) :
+ Float_t chi2perNDF ) :
AliVTrack(),
fRAtAbsorberEnd(0.),
fChi2perNDF(chi2perNDF),
fChi2MatchTrigger(0.),
+ fPID(0),
fFlags(0),
fLabel(label),
+ fTOFLabel(),
+ fTrackLength(0),
fITSMuonClusterMap(0),
+ fMUONtrigHitsMapTrg(0),
+ fMUONtrigHitsMapTrk(0),
fFilterMap(selectInfo),
+ fTPCFitMap(),
fTPCClusterMap(),
fTPCSharedMap(),
fTPCnclsF(0),
+ fTPCNCrossedRows(0),
fID(id),
fCharge(charge),
fType(ttype),
+ fPIDForTracking(AliPID::kPion),
fCaloIndex(kEMCALNoMatch),
fCovMatrix(NULL),
fDetPid(NULL),
- fProdVertex(prodVertex)
+ fDetectorPID(NULL),
+ fProdVertex(prodVertex),
+ fTrackPhiOnEMCal(-999),
+ fTrackEtaOnEMCal(-999),
+ fTrackPtOnEMCal(-999),
+ fIsMuonGlobalTrack(kFALSE), // AU
+ fTPCsignalTuned(0),
+ fTOFsignalTuned(99999),
+ fMFTClusterPattern(0), // AU
+ fAODEvent(NULL)
{
// constructor
SetUsedForVtxFit(usedForVtxFit);
SetUsedForPrimVtxFit(usedForPrimVtxFit);
if(covMatrix) SetCovMatrix(covMatrix);
- SetPID(pid);
SetITSClusterMap(itsClusMap);
+ for (Int_t i=0;i<3;i++) {fTOFLabel[i]=-1;}
}
//______________________________________________________________________________
// destructor
delete fCovMatrix;
delete fDetPid;
+ delete fDetectorPID;
+ if (fPID) {delete[] fPID; fPID = 0;}
}
fRAtAbsorberEnd(trk.fRAtAbsorberEnd),
fChi2perNDF(trk.fChi2perNDF),
fChi2MatchTrigger(trk.fChi2MatchTrigger),
+ fPID(0),
fFlags(trk.fFlags),
fLabel(trk.fLabel),
+ fTOFLabel(),
+ fTrackLength(trk.fTrackLength),
fITSMuonClusterMap(trk.fITSMuonClusterMap),
+ fMUONtrigHitsMapTrg(trk.fMUONtrigHitsMapTrg),
+ fMUONtrigHitsMapTrk(trk.fMUONtrigHitsMapTrk),
fFilterMap(trk.fFilterMap),
+ fTPCFitMap(trk.fTPCFitMap),
fTPCClusterMap(trk.fTPCClusterMap),
fTPCSharedMap(trk.fTPCSharedMap),
fTPCnclsF(trk.fTPCnclsF),
+ fTPCNCrossedRows(trk.fTPCNCrossedRows),
fID(trk.fID),
fCharge(trk.fCharge),
fType(trk.fType),
+ fPIDForTracking(trk.fPIDForTracking),
fCaloIndex(trk.fCaloIndex),
fCovMatrix(NULL),
fDetPid(NULL),
- fProdVertex(trk.fProdVertex)
+ fDetectorPID(NULL),
+ fProdVertex(trk.fProdVertex),
+ fTrackPhiOnEMCal(trk.fTrackPhiOnEMCal),
+ fTrackEtaOnEMCal(trk.fTrackEtaOnEMCal),
+ fTrackPtOnEMCal(trk.fTrackPtOnEMCal),
+ fIsMuonGlobalTrack(trk.fIsMuonGlobalTrack), // AU
+ fTPCsignalTuned(trk.fTPCsignalTuned),
+ fTOFsignalTuned(trk.fTOFsignalTuned),
+ fMFTClusterPattern(trk.fMFTClusterPattern), // AU
+ fAODEvent(trk.fAODEvent)
{
// Copy constructor
if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
SetPID(trk.fPID);
+ if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
+ for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}
}
//______________________________________________________________________________
trk.GetP(fMomentum);
trk.GetPosition(fPosition);
- trk.GetPID(fPID);
-
SetXYAtDCA(trk.XAtDCA(), trk.YAtDCA());
SetPxPyPzAtDCA(trk.PxAtDCA(), trk.PyAtDCA(), trk.PzAtDCA());
-
- fRAtAbsorberEnd = trk.fRAtAbsorberEnd;
-
- fChi2perNDF = trk.fChi2perNDF;
- fChi2MatchTrigger = trk.fChi2MatchTrigger;
-
- fFlags = trk.fFlags;
- fLabel = trk.fLabel;
-
+ fRAtAbsorberEnd = trk.fRAtAbsorberEnd;
+ fChi2perNDF = trk.fChi2perNDF;
+ fChi2MatchTrigger = trk.fChi2MatchTrigger;
+ SetPID( trk.fPID );
+ fFlags = trk.fFlags;
+ fLabel = trk.fLabel;
+ fTrackLength = trk.fTrackLength;
fITSMuonClusterMap = trk.fITSMuonClusterMap;
- fFilterMap = trk.fFilterMap;
-
- fID = trk.fID;
-
- fCharge = trk.fCharge;
- fType = trk.fType;
-
- fCaloIndex = trk.fCaloIndex;
-
+ fMUONtrigHitsMapTrg = trk.fMUONtrigHitsMapTrg;
+ fMUONtrigHitsMapTrk = trk.fMUONtrigHitsMapTrk;
+ fFilterMap = trk.fFilterMap;
+ fTPCFitMap = trk.fTPCFitMap;
+ fTPCClusterMap = trk.fTPCClusterMap;
+ fTPCSharedMap = trk.fTPCSharedMap;
+ fTPCnclsF = trk.fTPCnclsF;
+ fTPCNCrossedRows = trk.fTPCNCrossedRows;
+ fID = trk.fID;
+ fCharge = trk.fCharge;
+ fType = trk.fType;
+ fPIDForTracking = trk.fPIDForTracking;
+ fCaloIndex = trk.fCaloIndex;
+ fTrackPhiOnEMCal = trk.fTrackPhiOnEMCal;
+ fTrackEtaOnEMCal = trk.fTrackEtaOnEMCal;
+ fTrackPtOnEMCal = trk.fTrackPtOnEMCal;
+ fIsMuonGlobalTrack = trk.fIsMuonGlobalTrack; // AU
+ fTPCsignalTuned = trk.fTPCsignalTuned;
+ fTOFsignalTuned = trk.fTOFsignalTuned;
+ fMFTClusterPattern = trk.fMFTClusterPattern; // AU
+
delete fCovMatrix;
if(trk.fCovMatrix) fCovMatrix=new AliAODRedCov<6>(*trk.fCovMatrix);
else fCovMatrix=NULL;
- fProdVertex = trk.fProdVertex;
+
+ fProdVertex = trk.fProdVertex;
SetUsedForVtxFit(trk.GetUsedForVtxFit());
SetUsedForPrimVtxFit(trk.GetUsedForPrimVtxFit());
+ //detector raw signals
delete fDetPid;
if(trk.fDetPid) fDetPid=new AliAODPid(*trk.fDetPid);
else fDetPid=NULL;
+
+ //calibrated PID cache
+ delete fDetectorPID;
+ fDetectorPID=0x0;
+ if (trk.fDetectorPID) fDetectorPID = new AliDetectorPID(*trk.fDetectorPID);
+ for (Int_t i = 0; i < 3; i++) {fTOFLabel[i] = trk.fTOFLabel[i];}
}
return *this;
}
}
+void AliAODTrack::SetTOFLabel(const Int_t *p) {
+ // Sets (in TOF)
+ for (Int_t i = 0; i < 3; i++) fTOFLabel[i]=p[i];
+}
+
+//_______________________________________________________________________
+void AliAODTrack::GetTOFLabel(Int_t *p) const {
+ // Gets (in TOF)
+ for (Int_t i=0; i<3; i++) p[i]=fTOFLabel[i];
+}
+
//______________________________________________________________________________
AliAODTrack::AODTrkPID_t AliAODTrack::GetMostProbablePID() const
{
Int_t nPID = 10;
AODTrkPID_t loc = kUnknown;
- Double_t max = 0.;
Bool_t allTheSame = kTRUE;
-
- for (Int_t iPID = 0; iPID < nPID; iPID++) {
- if (fPID[iPID] >= max) {
- if (fPID[iPID] > max) {
- allTheSame = kFALSE;
- max = fPID[iPID];
- loc = (AODTrkPID_t)iPID;
- } else {
- allTheSame = kTRUE;
+ if (fPID) {
+ Double_t max = 0.;
+ for (Int_t iPID = 0; iPID < nPID; iPID++) {
+ if (fPID[iPID] >= max) {
+ if (fPID[iPID] > max) {
+ allTheSame = kFALSE;
+ max = fPID[iPID];
+ loc = (AODTrkPID_t)iPID;
+ } else {
+ allTheSame = kTRUE;
+ }
}
}
}
- return allTheSame ? kUnknown : loc;
+ return allTheSame ? AODTrkPID_t(GetPIDForTracking()) : loc;
}
//______________________________________________________________________________
// Converts AliPID array.
// The numbering scheme is the same for electrons, muons, pions, kaons, and protons.
// Everything else has to be set to zero.
-
- fPID[kDeuteron] = 0.;
- fPID[kTriton] = 0.;
- fPID[kHelium3] = 0.;
- fPID[kAlpha] = 0.;
- fPID[kUnknown] = 0.;
-
+ if (fPID) {
+ fPID[kDeuteron] = 0.;
+ fPID[kTriton] = 0.;
+ fPID[kHelium3] = 0.;
+ fPID[kAlpha] = 0.;
+ fPID[kUnknown] = 0.;
+ }
return;
}
//______________________________________________________________________________
-template <class T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
+template <typename T> void AliAODTrack::SetP(const T *p, const Bool_t cartesian)
{
// Set the momentum
}
}
+/*
//______________________________________________________________________________
-template <class T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
+template <typename T> void AliAODTrack::SetPosition(const T *x, const Bool_t dca)
{
// set the position
fPosition[2] = -999.;
}
}
-
+*/
//______________________________________________________________________________
void AliAODTrack::SetDCA(Double_t d, Double_t z)
{
// inside the beam pipe.
// return kFALSE is something went wrong
- // convert to AliExternalTrackParam
- AliExternalTrackParam etp(this);
-
- Float_t xstart = etp.GetX();
- if(xstart>3.) {
+ // allowed only for tracks inside the beam pipe
+ Float_t xstart2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
+ if(xstart2 > 3.*3.) { // outside beampipe radius
AliError("This method can be used only for propagation inside the beam pipe");
return kFALSE;
}
+ // convert to AliExternalTrackParam
+ AliExternalTrackParam etp; etp.CopyFromVTrack(this);
+
+ // propagate
if(!etp.PropagateToDCA(vtx,b,maxd,dz,covar)) return kFALSE;
// update track position and momentum
return kTRUE;
}
-//______________________________________________________________________________
-Float_t AliAODTrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1) const
+
+//_______________________________________________________________________
+Float_t AliAODTrack::GetTPCClusterInfo(Int_t nNeighbours/*=3*/, Int_t type/*=0*/, Int_t row0, Int_t row1, Int_t bitType ) const
{
//
- // TPC cluster information
+ // TPC cluster information
// type 0: get fraction of found/findable clusters with neighbourhood definition
// 1: findable clusters with neighbourhood definition
// 2: found clusters
- //
+ // bitType:
+ // 0 - all cluster used
+ // 1 - clusters used for the kalman update
// definition of findable clusters:
// a cluster is defined as findable if there is another cluster
// within +- nNeighbours pad rows. The idea is to overcome threshold
// effects with a very simple algorithm.
//
-
- if (type==2) return fTPCClusterMap.CountBits();
+
Int_t found=0;
Int_t findable=0;
Int_t last=-nNeighbours;
+ const TBits & clusterMap = (bitType%2==0) ? fTPCClusterMap : fTPCFitMap;
- for (Int_t i=row0; i<row1; ++i){
+ Int_t upperBound=clusterMap.GetNbits();
+ if (upperBound>row1) upperBound=row1;
+ for (Int_t i=row0; i<upperBound; ++i){
//look to current row
- if (fTPCClusterMap[i]) {
+ if (clusterMap[i]) {
last=i;
++found;
++findable;
}
//look to nNeighbours after
for (Int_t j=i+1; j<i+1+nNeighbours; ++j){
- if (fTPCClusterMap[j]){
+ if (clusterMap[j]){
++findable;
break;
}
}
}
+ if (type==2) return found;
if (type==1) return findable;
if (type==0){
Float_t fraction=0;
- if (findable>0)
+ if (findable>0)
fraction=(Float_t)found/(Float_t)findable;
- else
+ else
fraction=0;
return fraction;
- }
+ }
return 0; // undefined type - default value
}
+
//______________________________________________________________________________
Double_t AliAODTrack::GetTRDslice(Int_t plane, Int_t slice) const {
//
// return TRD Pid information
//
if (!fDetPid) return -1;
- Double32_t *trdSlices=fDetPid->GetTRDsignal();
+ Double32_t *trdSlices=fDetPid->GetTRDslices();
if (!trdSlices) return -1;
if ((plane<0) || (plane>=kTRDnPlanes)) {
return -1.;
return q/ns;
}
+//______________________________________________________________________________
+UChar_t AliAODTrack::GetTRDntrackletsPID() const{
+ //
+ // return number of tracklets calculated from the slices
+ //
+ if(!fDetPid) return -1;
+ return fDetPid->GetTRDntrackletsPID();
+}
+
+//______________________________________________________________________________
+UChar_t AliAODTrack::GetTRDncls(Int_t layer) const {
+ //
+ // return number of TRD clusters
+ //
+ if(!fDetPid || layer > 5) return -1;
+ if(layer < 0) return fDetPid->GetTRDncls();
+ else return fDetPid->GetTRDncls(layer);
+}
+
//______________________________________________________________________________
Double_t AliAODTrack::GetTRDmomentum(Int_t plane, Double_t */*sp*/) const
{
// in TRD layer "plane".
if (!fDetPid) return -1;
- Float_t *trdMomentum=fDetPid->GetTRDmomentum();
+ const Double_t *trdMomentum=fDetPid->GetTRDmomentum();
if (!trdMomentum) {
return -1.;
}
//_______________________________________________________________________
-Int_t AliAODTrack::GetTOFBunchCrossing(Double_t b) const
+Int_t AliAODTrack::GetTOFBunchCrossing(Double_t b, Bool_t) const
{
// Returns the number of bunch crossings after trigger (assuming 25ns spacing)
const double kSpacing = 25e3; // min interbanch spacing
if (IsOn(kTIME)) { // integrated time info is there
int pid = (int)GetMostProbablePID();
double ttimes[10];
- GetIntegratedTimes(ttimes);
+ GetIntegratedTimes(ttimes, pid>=AliPID::kSPECIES ? AliPID::kSPECIESC : AliPID::kSPECIES);
tdif -= ttimes[pid];
}
else { // assume integrated time info from TOF radius and momentum
bcid = TMath::Nint((tdif - kShift)/kSpacing);
return bcid;
}
+
+void AliAODTrack::SetDetectorPID(const AliDetectorPID *pid)
+{
+ //
+ // Set the detector PID
+ //
+ if (fDetectorPID) delete fDetectorPID;
+ fDetectorPID=pid;
+
+}
+
+//_____________________________________________________________________________
+Double_t AliAODTrack::GetHMPIDsignal() const
+{
+ if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpSignal();
+ else return -999.;
+}
+
+//_____________________________________________________________________________
+Double_t AliAODTrack::GetHMPIDoccupancy() const
+{
+ if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpOccupancy();
+ else return -999.;
+}
+
+//_____________________________________________________________________________
+Int_t AliAODTrack::GetHMPIDcluIdx() const
+{
+ if(fAODEvent->GetHMPIDringForTrackID(fID)) return fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpCluIdx();
+ else return -999;
+}
+
+//_____________________________________________________________________________
+void AliAODTrack::GetHMPIDtrk(Float_t &x, Float_t &y, Float_t &th, Float_t &ph) const
+{
+ x = -999; y = -999.; th = -999.; ph = -999.;
+
+ const AliAODHMPIDrings *ring=fAODEvent->GetHMPIDringForTrackID(fID);
+ if(ring){
+ x = ring->GetHmpTrackX();
+ y = ring->GetHmpTrackY();
+ th = ring->GetHmpTrackTheta();
+ ph = ring->GetHmpTrackPhi();
+ }
+}
+
+//_____________________________________________________________________________
+void AliAODTrack::GetHMPIDmip(Float_t &x,Float_t &y,Int_t &q, Int_t &nph) const
+{
+ x = -999; y = -999.; q = -999; nph = -999;
+
+ const AliAODHMPIDrings *ring=fAODEvent->GetHMPIDringForTrackID(fID);
+ if(ring){
+ x = ring->GetHmpMipX();
+ y = ring->GetHmpMipY();
+ q = (Int_t)ring->GetHmpMipCharge();
+ nph = (Int_t)ring->GetHmpNumOfPhotonClusters();
+ }
+}
+
+//_____________________________________________________________________________
+Bool_t AliAODTrack::GetOuterHmpPxPyPz(Double_t *p) const
+{
+ if(fAODEvent->GetHMPIDringForTrackID(fID)) {fAODEvent->GetHMPIDringForTrackID(fID)->GetHmpMom(p); return kTRUE;}
+
+ else return kFALSE;
+}
+//_____________________________________________________________________________
+Bool_t AliAODTrack::GetXYZAt(Double_t x, Double_t b, Double_t *r) const
+{
+ //---------------------------------------------------------------------
+ // This function returns the global track position extrapolated to
+ // the radial position "x" (cm) in the magnetic field "b" (kG)
+ //---------------------------------------------------------------------
+
+ //conversion of track parameter representation is
+ //based on the implementation of AliExternalTrackParam::Set(...)
+ //maybe some of this code can be moved to AliVTrack to avoid code duplication
+ Double_t alpha=0.0;
+ Double_t radPos2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
+ Double_t radMax = 45.; // approximately ITS outer radius
+ if (radPos2 < radMax*radMax) { // inside the ITS
+ alpha = fMomentum[1]; //TMath::ATan2(fMomentum[1],fMomentum[0]); // fMom is pt,phi,theta!
+ } else { // outside the ITS
+ Float_t phiPos = TMath::Pi()+TMath::ATan2(-fPosition[1], -fPosition[0]);
+ alpha =
+ TMath::DegToRad()*(20*((((Int_t)(phiPos*TMath::RadToDeg()))/20))+10);
+ }
+ //
+ // Get the vertex of origin and the momentum
+ TVector3 ver(fPosition[0],fPosition[1],fPosition[2]);
+ TVector3 mom(Px(),Py(),Pz());
+ //
+ // Rotate to the local coordinate system
+ ver.RotateZ(-alpha);
+ mom.RotateZ(-alpha);
+
+ Double_t param0 = ver.Y();
+ Double_t param1 = ver.Z();
+ Double_t param2 = TMath::Sin(mom.Phi());
+ Double_t param3 = mom.Pz()/mom.Pt();
+ Double_t param4 = TMath::Sign(1/mom.Pt(),(Double_t)fCharge);
+
+ //calculate the propagated coordinates
+ //this is based on AliExternalTrackParam::GetXYZAt(Double_t x, Double_t b, Double_t *r)
+ Double_t dx=x-ver.X();
+ if(TMath::Abs(dx)<=kAlmost0) return GetXYZ(r);
+
+ Double_t f1=param2;
+ Double_t f2=f1 + dx*param4*b*kB2C;
+
+ if (TMath::Abs(f1) >= kAlmost1) return kFALSE;
+ if (TMath::Abs(f2) >= kAlmost1) return kFALSE;
+
+ Double_t r1=TMath::Sqrt((1.-f1)*(1.+f1)), r2=TMath::Sqrt((1.-f2)*(1.+f2));
+ r[0] = x;
+ r[1] = param0 + dx*(f1+f2)/(r1+r2);
+ r[2] = param1 + dx*(r2 + f2*(f1+f2)/(r1+r2))*param3;//Thanks to Andrea & Peter
+ return Local2GlobalPosition(r,alpha);
+}
+
+//_____________________________________________________________________________
+Bool_t AliAODTrack::GetXYZatR(Double_t xr,Double_t bz, Double_t *xyz, Double_t* alpSect) const
+{
+ // This method has 3 modes of behaviour
+ // 1) xyz[3] array is provided but alpSect pointer is 0: calculate the position of track intersection
+ // with circle of radius xr and fill it in xyz array
+ // 2) alpSect pointer is provided: find alpha of the sector where the track reaches local coordinate xr
+ // Note that in this case xr is NOT the radius but the local coordinate.
+ // If the xyz array is provided, it will be filled by track lab coordinates at local X in this sector
+ // 3) Neither alpSect nor xyz pointers are provided: just check if the track reaches radius xr
+ //
+ //
+ Double_t alpha=0.0;
+ Double_t radPos2 = fPosition[0]*fPosition[0]+fPosition[1]*fPosition[1];
+ Double_t radMax = 45.; // approximately ITS outer radius
+ if (radPos2 < radMax*radMax) { // inside the ITS
+ alpha = fMomentum[1]; //TMath::ATan2(fMomentum[1],fMomentum[0]); // fMom is pt,phi,theta!
+ } else { // outside the ITS
+ Float_t phiPos = TMath::Pi()+TMath::ATan2(-fPosition[1], -fPosition[0]);
+ alpha =
+ TMath::DegToRad()*(20*((((Int_t)(phiPos*TMath::RadToDeg()))/20))+10);
+ }
+ //
+ // Get the vertex of origin and the momentum
+ TVector3 ver(fPosition[0],fPosition[1],fPosition[2]);
+ TVector3 mom(Px(),Py(),Pz());
+ //
+ // Rotate to the local coordinate system
+ ver.RotateZ(-alpha);
+ mom.RotateZ(-alpha);
+ //
+ Double_t fx = ver.X();
+ Double_t fy = ver.Y();
+ Double_t fz = ver.Z();
+ Double_t sn = TMath::Sin(mom.Phi());
+ Double_t tgl = mom.Pz()/mom.Pt();
+ Double_t crv = TMath::Sign(1/mom.Pt(),(Double_t)fCharge)*bz*kB2C;
+ //
+ if ( (TMath::Abs(bz))<kAlmost0Field ) crv=0.;
+ //
+ // general circle parameterization:
+ // x = (r0+tR)cos(phi0) - tR cos(t+phi0)
+ // y = (r0+tR)sin(phi0) - tR sin(t+phi0)
+ // where qb is the sign of the curvature, tR is the track's signed radius and r0
+ // is the DCA of helix to origin
+ //
+ double tR = 1./crv; // track radius signed
+ double cs = TMath::Sqrt((1-sn)*(1+sn));
+ double x0 = fx - sn*tR; // helix center coordinates
+ double y0 = fy + cs*tR;
+ double phi0 = TMath::ATan2(y0,x0); // angle of PCA wrt to the origin
+ if (tR<0) phi0 += TMath::Pi();
+ if (phi0 > TMath::Pi()) phi0 -= 2.*TMath::Pi();
+ else if (phi0 <-TMath::Pi()) phi0 += 2.*TMath::Pi();
+ double cs0 = TMath::Cos(phi0);
+ double sn0 = TMath::Sin(phi0);
+ double r0 = x0*cs0 + y0*sn0 - tR; // DCA to origin
+ double r2R = 1.+r0/tR;
+ //
+ //
+ if (r2R<kAlmost0) return kFALSE; // helix is centered at the origin, no specific intersection with other concetric circle
+ if (!xyz && !alpSect) return kTRUE;
+ double xr2R = xr/tR;
+ double r2Ri = 1./r2R;
+ // the intersection cos(t) = [1 + (r0/tR+1)^2 - (r0/tR)^2]/[2(1+r0/tR)]
+ double cosT = 0.5*(r2R + (1-xr2R*xr2R)*r2Ri);
+ if ( TMath::Abs(cosT)>kAlmost1 ) {
+ // printf("Does not reach : %f %f\n",r0,tR);
+ return kFALSE; // track does not reach the radius xr
+ }
+ //
+ double t = TMath::ACos(cosT);
+ if (tR<0) t = -t;
+ // intersection point
+ double xyzi[3];
+ xyzi[0] = x0 - tR*TMath::Cos(t+phi0);
+ xyzi[1] = y0 - tR*TMath::Sin(t+phi0);
+ if (xyz) { // if postition is requested, then z is needed:
+ double t0 = TMath::ATan2(cs,-sn) - phi0;
+ double z0 = fz - t0*tR*tgl;
+ xyzi[2] = z0 + tR*t*tgl;
+ }
+ else xyzi[2] = 0;
+ //
+ Local2GlobalPosition(xyzi,alpha);
+ //
+ if (xyz) {
+ xyz[0] = xyzi[0];
+ xyz[1] = xyzi[1];
+ xyz[2] = xyzi[2];
+ }
+ //
+ if (alpSect) {
+ double &alp = *alpSect;
+ // determine the sector of crossing
+ double phiPos = TMath::Pi()+TMath::ATan2(-xyzi[1],-xyzi[0]);
+ int sect = ((Int_t)(phiPos*TMath::RadToDeg()))/20;
+ alp = TMath::DegToRad()*(20*sect+10);
+ double x2r,f1,f2,r1,r2,dx,dy2dx,yloc=0, ylocMax = xr*TMath::Tan(TMath::Pi()/18); // min max Y within sector at given X
+ //
+ while(1) {
+ Double_t ca=TMath::Cos(alp-alpha), sa=TMath::Sin(alp-alpha);
+ if ((cs*ca+sn*sa)<0) {
+ AliDebug(1,Form("Rotation to target sector impossible: local cos(phi) would become %.2f",cs*ca+sn*sa));
+ return kFALSE;
+ }
+ //
+ f1 = sn*ca - cs*sa;
+ if (TMath::Abs(f1) >= kAlmost1) {
+ AliDebug(1,Form("Rotation to target sector impossible: local sin(phi) would become %.2f",f1));
+ return kFALSE;
+ }
+ //
+ double tmpX = fx*ca + fy*sa;
+ double tmpY = -fx*sa + fy*ca;
+ //
+ // estimate Y at X=xr
+ dx=xr-tmpX;
+ x2r = crv*dx;
+ f2=f1 + x2r;
+ if (TMath::Abs(f2) >= kAlmost1) {
+ AliDebug(1,Form("Propagation in target sector failed ! %.10e",f2));
+ return kFALSE;
+ }
+ r1 = TMath::Sqrt((1.-f1)*(1.+f1));
+ r2 = TMath::Sqrt((1.-f2)*(1.+f2));
+ dy2dx = (f1+f2)/(r1+r2);
+ yloc = tmpY + dx*dy2dx;
+ if (yloc>ylocMax) {alp += 2*TMath::Pi()/18; sect++;}
+ else if (yloc<-ylocMax) {alp -= 2*TMath::Pi()/18; sect--;}
+ else break;
+ if (alp >= TMath::Pi()) alp -= 2*TMath::Pi();
+ else if (alp < -TMath::Pi()) alp += 2*TMath::Pi();
+ // if (sect>=18) sect = 0;
+ // if (sect<=0) sect = 17;
+ }
+ //
+ // if alpha was requested, then recalculate the position at intersection in sector
+ if (xyz) {
+ xyz[0] = xr;
+ xyz[1] = yloc;
+ if (TMath::Abs(x2r)<0.05) xyz[2] = fz + dx*(r2 + f2*dy2dx)*tgl;
+ else {
+ // for small dx/R the linear apporximation of the arc by the segment is OK,
+ // but at large dx/R the error is very large and leads to incorrect Z propagation
+ // angle traversed delta = 2*asin(dist_start_end / R / 2), hence the arc is: R*deltaPhi
+ // The dist_start_end is obtained from sqrt(dx^2+dy^2) = x/(r1+r2)*sqrt(2+f1*f2+r1*r2)
+ // Similarly, the rotation angle in linear in dx only for dx<<R
+ double chord = dx*TMath::Sqrt(1+dy2dx*dy2dx); // distance from old position to new one
+ double rot = 2*TMath::ASin(0.5*chord*crv); // angular difference seen from the circle center
+ xyz[2] = fz + rot/crv*tgl;
+ }
+ Local2GlobalPosition(xyz,alp);
+ }
+ }
+ return kTRUE;
+ //
+}
+
+//_______________________________________________________
+void AliAODTrack::GetITSdEdxSamples(Double_t s[4]) const
+{
+ // get ITS dedx samples
+ if (!fDetPid) for (int i=4;i--;) s[i]=0;
+ else for (int i=4;i--;) s[i] = fDetPid->GetITSdEdxSample(i);
+}
+
+//_____________________________________________
+Double_t AliAODTrack::GetMassForTracking() const
+{
+ int pid = fPIDForTracking;
+ if (pid<AliPID::kPion) pid = AliPID::kPion;
+ double m = AliPID::ParticleMass(fPIDForTracking);
+ return (fPIDForTracking==AliPID::kHe3 || fPIDForTracking==AliPID::kAlpha) ? -m : m;
+}
+//_______________________________________________________
+const AliTOFHeader* AliAODTrack::GetTOFHeader() const {
+ return fAODEvent->GetTOFHeader();
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff