ClassImp(AliESDtrack)
-void SetPIDValues(Float_t * dest, const Double_t * src, Int_t n) {
+void SetPIDValues(Double_t * dest, const Double_t * src, Int_t n) {
// This function copies "n" PID weights from "scr" to "dest"
// and normalizes their sum to 1 thus producing conditional probabilities.
// The negative weights are set to 0.
//_______________________________________________________________________
AliESDtrack::AliESDtrack() :
AliExternalTrackParam(),
+ fCp(0),
+ fIp(0),
+ fTPCInner(0),
+ fOp(0),
+ fFriendTrack(new AliESDfriendTrack()),
+ fTPCClusterMap(159),//number of padrows
+ fTPCSharedMap(159),//number of padrows
fFlags(0),
- fLabel(0),
fID(0),
+ fLabel(0),
+ fITSLabel(0),
+ fTPCLabel(0),
+ fTRDLabel(0),
+ fTOFCalChannel(0),
+ fTOFindex(0),
+ fHMPIDqn(0),
+ fHMPIDcluIdx(0),
+ fEMCALindex(kEMCALNoMatch),
+ fHMPIDtrkTheta(0),
+ fHMPIDtrkPhi(0),
+ fHMPIDsignal(0),
fTrackLength(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
- fStopVertex(0),
- fCp(0),
- fCchi2(1e10),
- fIp(0),
- fOp(0),
+ fCchi2(0),
fITSchi2(0),
- fITSncls(0),
- fITSClusterMap(0),
- fITSsignal(0),
- fITSLabel(0),
fTPCchi2(0),
- fTPCncls(0),
- fTPCnclsF(0),
- fTPCClusterMap(159),//number of padrows
+ fTRDchi2(0),
+ fTOFchi2(0),
+ fHMPIDchi2(0),
+ fITSsignal(0),
fTPCsignal(0),
- fTPCsignalN(0),
fTPCsignalS(0),
- fTPCLabel(0),
- fTRDchi2(0),
- fTRDncls(0),
- fTRDncls0(0),
fTRDsignal(0),
- fTRDLabel(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFchi2(0),
- fTOFindex(0),
- fTOFCalChannel(-1),
- fTOFsignal(-1),
+ fTOFsignal(0),
fTOFsignalToT(0),
- fHMPIDchi2(1e10),
- fHMPIDqn(-1),
- fHMPIDcluIdx(-1),
- fHMPIDsignal(-1),
- fHMPIDtrkTheta(-1),
- fHMPIDtrkPhi(-1),
- fHMPIDtrkX(-1),
- fHMPIDtrkY(-1),
- fHMPIDmipX(-1),
- fHMPIDmipY(-1),
- fEMCALindex(kEMCALNoMatch),
- fFriendTrack(new AliESDfriendTrack())
+ fTOFsignalRaw(0),
+ fTOFsignalDz(0),
+ fHMPIDtrkX(0),
+ fHMPIDtrkY(0),
+ fHMPIDmipX(0),
+ fHMPIDmipY(0),
+ fTPCncls(0),
+ fTPCnclsF(0),
+ fTPCsignalN(0),
+ fITSncls(0),
+ fITSClusterMap(0),
+ fTRDncls(0),
+ fTRDncls0(0),
+ fTRDpidQuality(0)
{
//
// The default ESD constructor
Int_t i, j;
for (i=0; i<AliPID::kSPECIES; i++) {
fTrackTime[i]=0.;
- fR[i]=1.;
- fITSr[i]=1.;
- fTPCr[i]=1.;
- fTRDr[i]=1.;
- fTOFr[i]=1.;
- fHMPIDr[i]=1.;
+ fR[i]=0.;
+ fITSr[i]=0.;
+ fTPCr[i]=0.;
+ fTRDr[i]=0.;
+ fTOFr[i]=0.;
+ fHMPIDr[i]=0.;
}
for (i=0; i<3; i++) { fKinkIndexes[i]=0;}
- for (i=0; i<3; i++) { fV0Indexes[i]=-1;}
+ for (i=0; i<3; i++) { fV0Indexes[i]=0;}
for (i=0;i<kNPlane;i++) {
for (j=0;j<kNSlice;j++) {
fTRDsignals[i][j]=0.;
}
- fTRDTimBin[i]=-1;
+ fTRDTimBin[i]=0;
}
- for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
- for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
- for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
+ for (i=0;i<4;i++) {fTPCPoints[i]=0;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+ for (i=0;i<10;i++) {fTOFInfo[i]=0;}
+ for (i=0;i<12;i++) {fITSModule[i]=-1;}
}
//_______________________________________________________________________
AliESDtrack::AliESDtrack(const AliESDtrack& track):
AliExternalTrackParam(track),
+ fCp(0),
+ fIp(0),
+ fTPCInner(0),
+ fOp(0),
+ fFriendTrack(0),
+ fTPCClusterMap(track.fTPCClusterMap),
+ fTPCSharedMap(track.fTPCSharedMap),
fFlags(track.fFlags),
- fLabel(track.fLabel),
fID(track.fID),
+ fLabel(track.fLabel),
+ fITSLabel(track.fITSLabel),
+ fTPCLabel(track.fTPCLabel),
+ fTRDLabel(track.fTRDLabel),
+ fTOFCalChannel(track.fTOFCalChannel),
+ fTOFindex(track.fTOFindex),
+ fHMPIDqn(track.fHMPIDqn),
+ fHMPIDcluIdx(track.fHMPIDcluIdx),
+ fEMCALindex(track.fEMCALindex),
+ fHMPIDtrkTheta(track.fHMPIDtrkTheta),
+ fHMPIDtrkPhi(track.fHMPIDtrkPhi),
+ fHMPIDsignal(track.fHMPIDsignal),
fTrackLength(track.fTrackLength),
fD(track.fD),fZ(track.fZ),
fCdd(track.fCdd),fCdz(track.fCdz),fCzz(track.fCzz),
- fStopVertex(track.fStopVertex),
- fCp(0),
fCchi2(track.fCchi2),
- fIp(0),
- fOp(0),
fITSchi2(track.fITSchi2),
- fITSncls(track.fITSncls),
- fITSClusterMap(track.fITSClusterMap),
- fITSsignal(track.fITSsignal),
- fITSLabel(track.fITSLabel),
fTPCchi2(track.fTPCchi2),
- fTPCncls(track.fTPCncls),
- fTPCnclsF(track.fTPCnclsF),
- fTPCClusterMap(track.fTPCClusterMap),
+ fTRDchi2(track.fTRDchi2),
+ fTOFchi2(track.fTOFchi2),
+ fHMPIDchi2(track.fHMPIDchi2),
+ fITSsignal(track.fITSsignal),
fTPCsignal(track.fTPCsignal),
- fTPCsignalN(track.fTPCsignalN),
fTPCsignalS(track.fTPCsignalS),
- fTPCLabel(track.fTPCLabel),
- fTRDchi2(track.fTRDchi2),
- fTRDncls(track.fTRDncls),
- fTRDncls0(track.fTRDncls0),
fTRDsignal(track.fTRDsignal),
- fTRDLabel(track.fTRDLabel),
fTRDQuality(track.fTRDQuality),
fTRDBudget(track.fTRDBudget),
- fTOFchi2(track.fTOFchi2),
- fTOFindex(track.fTOFindex),
- fTOFCalChannel(track.fTOFCalChannel),
fTOFsignal(track.fTOFsignal),
fTOFsignalToT(track.fTOFsignalToT),
- fHMPIDchi2(track.fHMPIDchi2),
- fHMPIDqn(track.fHMPIDqn),
- fHMPIDcluIdx(track.fHMPIDcluIdx),
- fHMPIDsignal(track.fHMPIDsignal),
- fHMPIDtrkTheta(track.fHMPIDtrkTheta),
- fHMPIDtrkPhi(track.fHMPIDtrkPhi),
+ fTOFsignalRaw(track.fTOFsignalRaw),
+ fTOFsignalDz(track.fTOFsignalDz),
fHMPIDtrkX(track.fHMPIDtrkX),
fHMPIDtrkY(track.fHMPIDtrkY),
fHMPIDmipX(track.fHMPIDmipX),
fHMPIDmipY(track.fHMPIDmipY),
- fEMCALindex(track.fEMCALindex),
- fFriendTrack(0)
+ fTPCncls(track.fTPCncls),
+ fTPCnclsF(track.fTPCnclsF),
+ fTPCsignalN(track.fTPCsignalN),
+ fITSncls(track.fITSncls),
+ fITSClusterMap(track.fITSClusterMap),
+ fTRDncls(track.fTRDncls),
+ fTRDncls0(track.fTRDncls0),
+ fTRDpidQuality(track.fTRDpidQuality)
{
//
//copy constructor
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i]=track.fTOFr[i];
for (Int_t i=0;i<3;i++) fTOFLabel[i]=track.fTOFLabel[i];
for (Int_t i=0;i<10;i++) fTOFInfo[i]=track.fTOFInfo[i];
+ for (Int_t i=0;i<12;i++) fITSModule[i]=track.fITSModule[i];
for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i]=track.fHMPIDr[i];
if (track.fCp) fCp=new AliExternalTrackParam(*track.fCp);
if (track.fIp) fIp=new AliExternalTrackParam(*track.fIp);
+ if (track.fTPCInner) fTPCInner=new AliExternalTrackParam(*track.fTPCInner);
if (track.fOp) fOp=new AliExternalTrackParam(*track.fOp);
if (track.fFriendTrack) fFriendTrack=new AliESDfriendTrack(*(track.fFriendTrack));
//_______________________________________________________________________
AliESDtrack::AliESDtrack(TParticle * part) :
AliExternalTrackParam(),
+ fCp(0),
+ fIp(0),
+ fTPCInner(0),
+ fOp(0),
+ fFriendTrack(0),
+ fTPCClusterMap(159),//number of padrows
+ fTPCSharedMap(159),//number of padrows
fFlags(0),
- fLabel(0),
fID(0),
+ fLabel(0),
+ fITSLabel(0),
+ fTPCLabel(0),
+ fTRDLabel(0),
+ fTOFCalChannel(0),
+ fTOFindex(0),
+ fHMPIDqn(0),
+ fHMPIDcluIdx(0),
+ fEMCALindex(kEMCALNoMatch),
+ fHMPIDtrkTheta(0),
+ fHMPIDtrkPhi(0),
+ fHMPIDsignal(0),
fTrackLength(0),
fD(0),fZ(0),
fCdd(0),fCdz(0),fCzz(0),
- fStopVertex(0),
- fCp(0),
- fCchi2(1e10),
- fIp(0),
- fOp(0),
+ fCchi2(0),
fITSchi2(0),
- fITSncls(0),
- fITSClusterMap(0),
- fITSsignal(0),
- fITSLabel(0),
fTPCchi2(0),
- fTPCncls(0),
- fTPCnclsF(0),
- fTPCClusterMap(159),//number of padrows
+ fTRDchi2(0),
+ fTOFchi2(0),
+ fHMPIDchi2(0),
+ fITSsignal(0),
fTPCsignal(0),
- fTPCsignalN(0),
fTPCsignalS(0),
- fTPCLabel(0),
- fTRDchi2(0),
- fTRDncls(0),
- fTRDncls0(0),
fTRDsignal(0),
- fTRDLabel(0),
fTRDQuality(0),
fTRDBudget(0),
- fTOFchi2(0),
- fTOFindex(0),
- fTOFCalChannel(-1),
- fTOFsignal(-1),
+ fTOFsignal(0),
fTOFsignalToT(0),
- fHMPIDchi2(1e10),
- fHMPIDqn(-1),
- fHMPIDcluIdx(-1),
- fHMPIDsignal(-1),
- fHMPIDtrkTheta(-1),
- fHMPIDtrkPhi(-1),
- fHMPIDtrkX(-1),
- fHMPIDtrkY(-1),
- fHMPIDmipX(-1),
- fHMPIDmipY(-1),
- fEMCALindex(kEMCALNoMatch),
- fFriendTrack(0)
+ fTOFsignalRaw(0),
+ fTOFsignalDz(0),
+ fHMPIDtrkX(0),
+ fHMPIDtrkY(0),
+ fHMPIDmipX(0),
+ fHMPIDmipY(0),
+ fTPCncls(0),
+ fTPCnclsF(0),
+ fTPCsignalN(0),
+ fITSncls(0),
+ fITSClusterMap(0),
+ fTRDncls(0),
+ fTRDncls0(0),
+ fTRDpidQuality(0)
{
//
// ESD track from TParticle
for (j=0;j<kNSlice;j++) {
fTRDsignals[i][j]=0.;
}
- fTRDTimBin[i]=-1;
+ fTRDTimBin[i]=0;
}
- for (i=0;i<4;i++) {fTPCPoints[i]=-1;}
- for (i=0;i<3;i++) {fTOFLabel[i]=-1;}
- for (i=0;i<10;i++) {fTOFInfo[i]=-1;}
+ for (i=0;i<4;i++) {fTPCPoints[i]=0;}
+ for (i=0;i<3;i++) {fTOFLabel[i]=0;}
+ for (i=0;i<10;i++) {fTOFInfo[i]=0;}
+ for (i=0;i<12;i++) {fITSModule[i]=-1;}
// Calculate the AliExternalTrackParam content
//
//printf("Delete track\n");
delete fIp;
+ delete fTPCInner;
delete fOp;
delete fCp;
delete fFriendTrack;
// Running track parameters in the base class (AliExternalTrackParam)
fTrackLength = 0;
+
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTrackTime[i] = 0;
- fStopVertex = 0;
// Reset track parameters constrained to the primary vertex
- fCp = 0;
+ delete fCp;fCp = 0;
fCchi2 = 0;
// Reset track parameters at the inner wall of TPC
- fIp = 0;
-
+ delete fIp;fIp = 0;
+ delete fTPCInner;fTPCInner=0;
// Reset track parameters at the inner wall of the TRD
- fOp = 0;
+ delete fOp;fOp = 0;
+
// Reset ITS track related information
fITSchi2 = 0;
fTPCncls = 0;
fTPCnclsF = 0;
fTPCClusterMap = 0;
+ fTPCSharedMap = 0;
fTPCsignal= 0;
fTPCsignalS= 0;
fTPCsignalN= 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTRDr[i] = 0;
fTRDLabel = 0;
fTRDQuality = 0;
+ fTRDpidQuality = 0;
fTRDBudget = 0;
// Reset TOF related track information
fTOFchi2 = 0;
fTOFindex = 0;
fTOFsignal = 0;
- fTOFCalChannel = -1;
+ fTOFCalChannel = 0;
fTOFsignalToT = 0;
+ fTOFsignalRaw = 0;
+ fTOFsignalDz = 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fTOFr[i] = 0;
for (Int_t i=0;i<3;i++) fTOFLabel[i] = 0;
for (Int_t i=0;i<10;i++) fTOFInfo[i] = 0;
// Reset HMPID related track information
fHMPIDchi2 = 0;
- fHMPIDqn = -1;
- fHMPIDcluIdx = -1;
+ fHMPIDqn = 0;
+ fHMPIDcluIdx = 0;
fHMPIDsignal = 0;
for (Int_t i=0;i<AliPID::kSPECIES;i++) fHMPIDr[i] = 0;
- fHMPIDtrkTheta = -1;
- fHMPIDtrkPhi = -1;
- fHMPIDtrkX = -1;
- fHMPIDtrkY = -1;
- fHMPIDmipX = -1;
- fHMPIDmipY = -1;
+ fHMPIDtrkTheta = 0;
+ fHMPIDtrkPhi = 0;
+ fHMPIDtrkX = 0;
+ fHMPIDtrkY = 0;
+ fHMPIDmipX = 0;
+ fHMPIDmipY = 0;
fEMCALindex = kEMCALNoMatch;
delete fFriendTrack; fFriendTrack = 0;
return AliPID::ParticleMass(AliPID::kPion);
}
+//______________________________________________________________________________
+Double_t AliESDtrack::E() const
+{
+ // Returns the energy of the particle given its assumed mass.
+ // Assumes the pion mass if the particle can't be identified properly.
+
+ Double_t m = M();
+ Double_t p = P();
+ return TMath::Sqrt(p*p + m*m);
+}
+
+//______________________________________________________________________________
+Double_t AliESDtrack::Y() const
+{
+ // Returns the rapidity of a particle given its assumed mass.
+ // Assumes the pion mass if the particle can't be identified properly.
+
+ Double_t e = E();
+ Double_t pz = Pz();
+ if (e != TMath::Abs(pz)) { // energy was not equal to pz
+ return 0.5*TMath::Log((e+pz)/(e-pz));
+ } else { // energy was equal to pz
+ return -999.;
+ }
+}
+
//_______________________________________________________________________
Bool_t AliESDtrack::UpdateTrackParams(const AliKalmanTrack *t, ULong_t flags){
//
switch (flags) {
case kITSin: case kITSout: case kITSrefit:
+ fITSClusterMap=0;
fITSncls=t->GetNumberOfClusters();
index=fFriendTrack->GetITSindices();
for (Int_t i=0;i<AliESDfriendTrack::kMaxITScluster;i++) {
case kTPCin: case kTPCrefit:
fTPCLabel = t->GetLabel();
+ if (flags==kTPCin) fTPCInner=new AliExternalTrackParam(*t);
if (!fIp) fIp=new AliExternalTrackParam(*t);
else
fIp->Set(t->GetX(),t->GetAlpha(),t->GetParameter(),t->GetCovariance());
case kTRDout: case kTRDin: case kTRDrefit:
index=fFriendTrack->GetTRDindices();
fTRDLabel = t->GetLabel();
- fTRDncls=t->GetNumberOfClusters();
fTRDchi2=t->GetChi2();
- for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
+ fTRDncls=6;//t->GetNumberOfTracklets(); //t->GetNumberOfClusters();
+ //for (Int_t i=0;i<fTRDncls;i++) index[i]=t->GetClusterIndex(i);
+ for (Int_t i=0;i<6;i++) index[i]=t->GetTrackletIndex(i);
+
fTRDsignal=t->GetPIDsignal();
break;
case kTRDbackup:
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetITSclusters(Int_t *idx) const {
+Char_t AliESDtrack::GetITSclusters(Int_t *idx) const {
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
+Bool_t AliESDtrack::GetITSModuleIndexInfo(Int_t ilayer,Int_t &idet,Int_t &status,
+ Float_t &xloc,Float_t &zloc) const {
+ //----------------------------------------------------------------------
+ // This function encodes in the module number also the status of cluster association
+ // "status" can have the following values:
+ // 1 "found" (cluster is associated),
+ // 2 "dead" (module is dead from OCDB),
+ // 3 "skipped" (module or layer forced to be skipped),
+ // 4 "outinz" (track out of z acceptance),
+ // 5 "nocls" (no clusters in the road),
+ // 6 "norefit" (cluster rejected during refit),
+ // 7 "deadzspd" (holes in z in SPD)
+ // Also given are the coordinates of the crossing point of track and module
+ // (in the local module ref. system)
+ // WARNING: THIS METHOD HAS TO BE SYNCHRONIZED WITH AliITStrackV2::GetModuleIndexInfo()!
+ //----------------------------------------------------------------------
+
+ if(fITSModule[ilayer]==-1) {
+ AliError("fModule was not set !");
+ idet = -1;
+ status=0;
+ xloc=-99.; zloc=-99.;
+ return kFALSE;
+ }
+
+ Int_t module = fITSModule[ilayer];
+
+ idet = Int_t(module/1000000);
+
+ module -= idet*1000000;
+
+ status = Int_t(module/100000);
+
+ module -= status*100000;
+
+ Int_t signs = Int_t(module/10000);
+
+ module-=signs*10000;
+
+ Int_t xInt = Int_t(module/100);
+ module -= xInt*100;
+
+ Int_t zInt = module;
+
+ if(signs==1) { xInt*=1; zInt*=1; }
+ if(signs==2) { xInt*=1; zInt*=-1; }
+ if(signs==3) { xInt*=-1; zInt*=1; }
+ if(signs==4) { xInt*=-1; zInt*=-1; }
+
+ xloc = 0.1*(Float_t)xInt;
+ zloc = 0.1*(Float_t)zInt;
+
+ if(status==4) idet = -1;
+
+ return kTRUE;
+}
+
+//_______________________________________________________________________
+UShort_t AliESDtrack::GetTPCclusters(Int_t *idx) const {
//---------------------------------------------------------------------
// This function returns indices of the assgined ITS clusters
//---------------------------------------------------------------------
return fTPCncls;
}
-Float_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
+Double_t AliESDtrack::GetTPCdensity(Int_t row0, Int_t row1) const{
//
// GetDensity of the clusters on given region between row0 and row1
// Dead zone effect takin into acoount
}
//_______________________________________________________________________
-Int_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
+UChar_t AliESDtrack::GetTRDclusters(Int_t *idx) const {
//---------------------------------------------------------------------
// This function returns indices of the assgined TRD clusters
//---------------------------------------------------------------------
return fTRDncls;
}
+//_______________________________________________________________________
+UChar_t AliESDtrack::GetTRDtracklets(Int_t *idx) const {
+ //---------------------------------------------------------------------
+ // This function returns indices of the assigned TRD tracklets
+ //---------------------------------------------------------------------
+ if (idx!=0) {
+ Int_t *index=fFriendTrack->GetTRDindices();
+ for (Int_t i=0; i<6/*AliESDfriendTrack::kMaxTRDcluster*/; i++) idx[i]=index[i];
+ }
+ return fTRDncls;
+}
+
//_______________________________________________________________________
void AliESDtrack::SetTRDpid(const Double_t *p) {
// Sets values for the probability of each particle type (in TRD)
fTRDr[iSpecies] = p;
}
-Float_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
+Double_t AliESDtrack::GetTRDpid(Int_t iSpecies) const
{
// Returns the probability of particle type iSpecies (in TRD)
return fTRDr[iSpecies];
}
}
-Bool_t AliESDtrack::PropagateTo(Double_t xToGo, Double_t b, Double_t mass,
-Double_t maxStep, Bool_t rotateTo, Double_t maxSnp){
- //----------------------------------------------------------------
- //
- // MI's function
- //
- // Propagates this track to the plane X=xk (cm)
- // in the magnetic field "b" (kG),
- // the correction for the material is included
- //
- // mass - mass used in propagation - used for energy loss correction
- // maxStep - maximal step for propagation
- //----------------------------------------------------------------
- const Double_t kEpsilon = 0.00001;
- Double_t xpos = GetX();
- Double_t dir = (xpos<xToGo) ? 1.:-1.;
- //
- while ( (xToGo-xpos)*dir > kEpsilon){
- Double_t step = dir*TMath::Min(TMath::Abs(xToGo-xpos), maxStep);
- Double_t x = xpos+step;
- Double_t xyz0[3],xyz1[3],param[7];
- GetXYZ(xyz0); //starting global position
- if (!GetXYZAt(x,b,xyz1)) return kFALSE; // no prolongation
- xyz1[2]+=kEpsilon; // waiting for bug correction in geo
- AliKalmanTrack::MeanMaterialBudget(xyz0,xyz1,param);
- if (TMath::Abs(GetSnpAt(x,b)) >= maxSnp) return kFALSE;
- if (!AliExternalTrackParam::PropagateTo(x,b)) return kFALSE;
-
- Double_t rho=param[0],x0=param[1],distance=param[4];
- Double_t d=distance*rho/x0;
-
- if (!CorrectForMaterial(d,x0,mass)) return kFALSE;
- if (rotateTo){
- if (TMath::Abs(GetSnp()) >= maxSnp) return kFALSE;
- GetXYZ(xyz0); // global position
- Double_t alphan = TMath::ATan2(xyz0[1], xyz0[0]);
- //
- Double_t ca=TMath::Cos(alphan-GetAlpha()),
- sa=TMath::Sin(alphan-GetAlpha());
- Double_t sf=GetSnp(), cf=TMath::Sqrt(1.- sf*sf);
- Double_t sinNew = sf*ca - cf*sa;
- if (TMath::Abs(sinNew) >= maxSnp) return kFALSE;
- if (!Rotate(alphan)) return kFALSE;
- }
- xpos = GetX();
- }
- return kTRUE;
-}