EMCAL/AliEMCALTrack.cxx

   1 //========================================================================
   2 // Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved.
   3 //
   4 // Author: The ALICE Off-line Project.
   5 // Contributors are mentioned in the code where appropriate.
   6 //
   7 // Permission to use, copy, modify and distribute this software and its
   8 // documentation strictly for non-commercial purposes is hereby granted
   9 // without fee, provided that the above copyright notice appears in all
  10 // copies and that both the copyright notice and this permission notice
  11 // appear in the supporting documentation. The authors make no claims
  12 // about the suitability of this software for any purpose. It is
  13 // provided "as is" without express or implied warranty.
  14 //========================================================================
  15 //
  16 //                       Class AliEMCALTrack
  17 //                      ---------------------
  18 //    A class implementing a track which is propagated to EMCAL and
  19 //    matches and EMCAL cluster.
  20 //    This track object will not update Kalman parameters, but it
  21 //    allows for track propagation and suitable energy loss correction,
  22 //    even in an environment with a variable magnetic field, which is not
  23 //    well managed in the AliExternalTrackParam class.
  24 // ------------------------------------------------------------------------
  25 // author: A. Pulvirenti (alberto.pulvirenti@ct.infn.it)
  26 //=========================================================================
  27
  28 #include "Riostream.h"
  29
  30 #include "TVector3.h"
  31
  32 #include "AliLog.h"
  33 #include "AliTracker.h"
  34 #include "AliESDtrack.h"
  35
  36 #include "AliEMCALTrack.h"
  37
  38 Bool_t AliEMCALTrack::fgUseOuterParams = kTRUE;
  39 Bool_t AliEMCALTrack::fgCorrectForEL   = kFALSE;
  40 Bool_t AliEMCALTrack::fgSortByPt       = kTRUE;
  41
  42 ClassImp(AliEMCALTrack)
  43 //
  44 //------------------------------------------------------------------------------
  45 //
  46 AliEMCALTrack::AliEMCALTrack()
  47   : AliExternalTrackParam(),
  48     fClusterIndex(-1),
  49     fClusterDist(1000.0),          // default: extremely large distance
  50     fMass(0.13957018),             // default: pion mass
  51     fSeedIndex(-1),
  52     fSeedLabel(-1)
  53 {
  54         //
  55         // Default constructor.
  56         // Sets to meaningless values the indexes corresponding to
  57         // ESD seed track and matched cluster.
  58         //
  59
  60 }
  61 //
  62 //------------------------------------------------------------------------------
  63 //
  64 AliEMCALTrack::AliEMCALTrack(const AliESDtrack& t)
  65   : AliExternalTrackParam(),
  66     fClusterIndex(-1),
  67     fClusterDist(1000.0),
  68     fMass(t.GetMass()),
  69     fSeedIndex(-1),
  70     fSeedLabel(t.GetLabel())
  71 {
  72         //
  73         // Constructor from AliESDtrack
  74         //
  75
  76         // parameters are chosen according to static variable fUseOuterParams
  77         Double_t alpha, x, params[5], cov[15];
  78         if (fgUseOuterParams) {
  79           if(t.GetOuterParam()){
  80             t.GetOuterExternalParameters(alpha, x, params);
  81             t.GetOuterExternalCovariance(cov);
  82           }
  83           else{ // no outer param available leave the default as is
  84             return;
  85           }
  86         }
  87         else {
  88                 alpha = t.GetAlpha();
  89                 t.GetExternalParameters(x, params);
  90                 t.GetExternalCovariance(cov);
  91         }
  92
  93         if (alpha < -TMath::Pi()) alpha += TMath::TwoPi();
  94         else if (alpha >= TMath::Pi()) alpha -= TMath::TwoPi();
  95
  96         // set this accordingly
  97         Set(x, alpha, params, cov);
  98 }
  99 //
 100 //------------------------------------------------------------------------------
 101 //
 102 AliEMCALTrack::AliEMCALTrack(const AliEMCALTrack& t)
 103   : AliExternalTrackParam(t),
 104     fClusterIndex(t.fClusterIndex),
 105     fClusterDist(t.fClusterDist),
 106     fMass(t.fMass),
 107     fSeedIndex(t.fSeedIndex),
 108     fSeedLabel(t.fSeedLabel)
 109 {
 110         //
 111         // Copy constructor.
 112         //
 113 }
 114 //
 115 //------------------------------------------------------------------------------
 116 //
 117 AliEMCALTrack& AliEMCALTrack::operator=(const AliEMCALTrack &t)
 118 {
 119         //
 120         // Assignment operator
 121         // Works like copy constructor
 122         //
 123
 124         fClusterIndex = t.fClusterIndex;
 125         fClusterDist = t.fClusterDist;
 126
 127         fMass = t.fMass;
 128
 129         fSeedIndex = t.fSeedIndex;
 130         fSeedLabel = t.fSeedLabel;
 131         return *this;
 132 }
 133 //
 134 //------------------------------------------------------------------------------
 135 //
 136 Int_t AliEMCALTrack::Compare(const TObject *obj) const
 137 {
 138         //
 139         // Compare tracks.
 140         // How tracks are compared depends on the static flag
 141         // "fSortByPt" (boolean):
 142         // true  => tracks are compared w.r. to their transverse momentum
 143         // false => tracks are compared w.r. to their distance from cluster
 144         //
 145
 146         AliEMCALTrack *that = (AliEMCALTrack*)obj;
 147
 148         Double_t thisP[3], thisVal, thatP[3], thatVal;
 149
 150         if (fgSortByPt) {
 151                 this->GetPxPyPz(thisP);
 152                 that->GetPxPyPz(thatP);
 153                 thisVal = TMath::Sqrt(thisP[0]*thisP[0] + thisP[1]*thisP[1]);
 154                 thatVal = TMath::Sqrt(thatP[0]*thatP[0] + thatP[1]*thatP[1]);
 155         }
 156         else {
 157                 thisVal = this->GetClusterDist();
 158                 thatVal = that->GetClusterDist();
 159         }
 160
 161         if (thisVal > thatVal) return 1;
 162         else if (thisVal < thatVal) return -1;
 163         else return 0;
 164 }
 165 //
 166 //------------------------------------------------------------------------------
 167 //
 168 Double_t AliEMCALTrack::GetBz() const
 169 {
 170         //
 171         // Returns Z-component of the magnetic field in kG.
 172         // In case it B is not constant, its value is returned
 173         // at the current position of the track (local X,Y,Z)
 174         //
 175
 176         // if magnetic field is constant...
 177         if (AliTracker::UniformField()) return AliTracker::GetBz();
 178
 179         // ...else:
 180         Double_t r[3];
 181         GetXYZ(r);
 182         return AliTracker::GetBz(r);
 183 }
 184 //
 185 //------------------------------------------------------------------------------
 186 //
 187 Bool_t AliEMCALTrack::PropagateTo(Double_t xk, Double_t d, Double_t x0)
 188 {
 189         //
 190         // Propagates a track to the plane defined by x='xk'.
 191         // Second parameter is the width (in units of rad. length) crossed by the track.
 192         // Third parameter is the reference radiation length used.
 193         // Track propagation includes computing energy loss (modifies curvature)
 194         // and multiple scattering perturbation (alters covariance matrix), if requested.
 195         // Method returns kFALSE when something goes wrong with computations.
 196         //
 197         // An additional operation (thanks to Yuri Belikov) is done to check
 198         // when the track crosses a sector boundary. If this happens,
 199         // the local track reference frame is adjusted accordingly.
 200         //
 201
 202         Double_t y;
 203         Double_t field = GetBz();
 204         Double_t width = TMath::Pi() / 9.0; // width of TPC/TRD/EMCAL sector (= 20 deg)
 205         Double_t ymax  = TMath::Abs(xk * TMath::Tan(0.5 * width)); // max allowed Y in local coords at distance xk
 206
 207         // first check: try to compute the local 'y' at the distance 'xk':
 208         // if this attempt fails, the propagation cannot be done
 209         if (!GetYAt(xk, field, y)) return kFALSE;
 210
 211         // if is -ymax < y < ymax ==> 'direct' propagation is done;
 212         if (TMath::Abs(y) <= ymax) return SimplePropagation(xk, d, x0);
 213
 214         // otherwise, try change a sector to find one where the propagation is ok
 215         Int_t    i, incr, istart, nloops;
 216         Double_t alpha = GetAlpha();
 217         incr = (y > ymax) ? 1 : -1;
 218         if (alpha < 0.0) alpha += TMath::TwoPi();
 219         istart = (Int_t)(alpha / width);
 220         for (i = istart, nloops = 0; nloops < 18; i += incr, nloops++) {
 221                 if (i == 18) i = 0;
 222                 if (i == -1) i = 17;
 223                 alpha = ((Double_t)i + 0.5) * width;
 224                 if (Rotate(alpha)) {
 225                         if (GetYAt(xk, field, y)) {
 226                                 if (TMath::Abs(y) <= ymax) {
 227                                   AliDebug(1,Form("Required change from sector %d to sector %d to succeed in propagation", istart, i));
 228                                         return SimplePropagation(xk, d, x0);
 229                                 }
 230                         }
 231                 }
 232         }
 233
 234         // if the routine exits from the loop and reaches this point,
 235         // it means that none of the rotations succeeded
 236         AliWarning("Track propagation fails in every sector. Impossible to propagate.");
 237         return kFALSE;
 238 }
 239 //
 240 //------------------------------------------------------------------------------
 241 //
 242 Double_t AliEMCALTrack::StraightPropagateTo(Double_t xk, Double_t &x, Double_t &y, Double_t &z)
 243 {
 244         //
 245         // Does propagation with a straight line approximation.
 246         // This operation does not update track parameters, but it returns a point
 247         // in space, according to this propagation, which is stored in
 248         // the arguments #2, #3 and #4
 249         //
 250
 251         Double_t oldX = GetX(), oldY = GetY(), oldZ = GetZ();
 252         Double_t newPos[3];
 253
 254         newPos[0] = xk;
 255         newPos[1] = oldY * xk / oldX;
 256         newPos[2] = oldZ * xk / oldX;
 257
 258         Double_t cs = TMath::Cos(GetAlpha()), sn = TMath::Sin(GetAlpha());
 259         x = newPos[0]*cs - newPos[1]*sn;
 260         y = newPos[0]*sn + newPos[1]*cs;
 261         z = newPos[2];
 262
 263         return newPos[1];
 264 }
 265 //
 266 //------------------------------------------------------------------------------
 267 //
 268 Bool_t AliEMCALTrack::PropagateToGlobal(Double_t x, Double_t y, Double_t z, Double_t d, Double_t x0)
 269 {
 270         //
 271         // Propagate to a point specified with its global XYZ coordinates.
 272         // Here, the correct value of the 'X' parameter to be sent to "PropagateTo" is computed.
 273         //
 274
 275         TVector3 vc(x, y, z);
 276         Double_t width = 20.0; // width of TPC/TRD/EMCAL sector
 277         Double_t phi   = vc.Phi() * TMath::RadToDeg();
 278         if (phi < 0.0) phi += 360.0;
 279
 280         Int_t    isector = (Int_t)(phi / width);
 281         Double_t rotation = ((Double_t)isector + 0.5) * width;
 282         vc.RotateZ(-rotation * TMath::DegToRad());
 283
 284         return PropagateTo(vc.X(), d, x0);
 285 }
 286 //
 287 //------------------------------------------------------------------------------
 288 //
 289 Bool_t AliEMCALTrack::SimplePropagation(Double_t xk, Double_t d, Double_t x0)
 290 {
 291         //
 292         // Recall base class method for track propagation.
 293         //
 294
 295         Double_t field = GetBz();
 296
 297         // propagation...
 298         if (!AliExternalTrackParam::PropagateTo(xk, field)) return kFALSE;
 299
 300         // EL correction is computed only if requested...
 301         if (!fgCorrectForEL) return kTRUE;
 302         return AliExternalTrackParam::CorrectForMeanMaterial(d, x0, GetMass());
 303 }