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 "AliESDtrack.h"
  34
  35 #include "AliEMCALTrack.h"
  36
  37 Bool_t AliEMCALTrack::fgUseOuterParams = kTRUE;
  38 Bool_t AliEMCALTrack::fgCorrectForEL   = kFALSE;
  39 Bool_t AliEMCALTrack::fgSortByPt       = kTRUE;
  40
  41 ClassImp(AliEMCALTrack)
  42 //
  43 //------------------------------------------------------------------------------
  44 //
  45 AliEMCALTrack::AliEMCALTrack()
  46   : AliExternalTrackParam(),
  47     fClusterIndex(-1),
  48     fClusterDist(1000.0),          // default: extremely large distance
  49     fMass(0.13957018),             // default: pion mass
  50     fSeedIndex(-1),
  51     fSeedLabel(-1)
  52 {
  53         //
  54         // Default constructor.
  55         // Sets to meaningless values the indexes corresponding to
  56         // ESD seed track and matched cluster.
  57         //
  58
  59 }
  60 //
  61 //------------------------------------------------------------------------------
  62 //
  63 AliEMCALTrack::AliEMCALTrack(const AliESDtrack& t)
  64   : AliExternalTrackParam(),
  65     fClusterIndex(-1),
  66     fClusterDist(1000.0),
  67     fMass(t.GetMass(kTRUE)),
  68     fSeedIndex(-1),
  69     fSeedLabel(t.GetLabel())
  70 {
  71         //
  72         // Constructor from AliESDtrack
  73         //
  74
  75         // parameters are chosen according to static variable fUseOuterParams
  76         Double_t alpha=0., x=0., params[5], cov[15];
  77         if (fgUseOuterParams) {
  78           if(t.GetOuterParam()){
  79             t.GetOuterExternalParameters(alpha, x, params);
  80             t.GetOuterExternalCovariance(cov);
  81           }
  82           else{ // no outer param available leave the default as is
  83             return;
  84           }
  85         }
  86         else {
  87                 alpha = t.GetAlpha();
  88                 t.GetExternalParameters(x, params);
  89                 t.GetExternalCovariance(cov);
  90         }
  91
  92         if (alpha < -TMath::Pi()) alpha += TMath::TwoPi();
  93         else if (alpha >= TMath::Pi()) alpha -= TMath::TwoPi();
  94
  95         // set this accordingly
  96         Set(x, alpha, params, cov);
  97 }
  98 //
  99 //------------------------------------------------------------------------------
 100 //
 101 AliEMCALTrack::AliEMCALTrack(const AliEMCALTrack& t)
 102   : AliExternalTrackParam(t),
 103     fClusterIndex(t.fClusterIndex),
 104     fClusterDist(t.fClusterDist),
 105     fMass(t.fMass),
 106     fSeedIndex(t.fSeedIndex),
 107     fSeedLabel(t.fSeedLabel)
 108 {
 109         //
 110         // Copy constructor.
 111         //
 112 }
 113 //
 114 //------------------------------------------------------------------------------
 115 //
 116 AliEMCALTrack& AliEMCALTrack::operator=(const AliEMCALTrack &source)
 117 { // assignment operator; use copy ctor
 118   if (&source == this) return *this;
 119
 120   new (this) AliEMCALTrack(source);
 121   return *this;
 122 }
 123 //
 124 //------------------------------------------------------------------------------
 125 //
 126 Int_t AliEMCALTrack::Compare(const TObject *obj) const
 127 {
 128         //
 129         // Compare tracks.
 130         // How tracks are compared depends on the static flag
 131         // "fSortByPt" (boolean):
 132         // true  => tracks are compared w.r. to their transverse momentum
 133         // false => tracks are compared w.r. to their distance from cluster
 134         //
 135
 136         AliEMCALTrack *that = (AliEMCALTrack*)obj;
 137
 138         Double_t thisP[3], thisVal=0., thatP[3], thatVal=0.;
 139
 140         if (fgSortByPt) {
 141                 this->GetPxPyPz(thisP);
 142                 that->GetPxPyPz(thatP);
 143                 thisVal = TMath::Sqrt(thisP[0]*thisP[0] + thisP[1]*thisP[1]);
 144                 thatVal = TMath::Sqrt(thatP[0]*thatP[0] + thatP[1]*thatP[1]);
 145         }
 146         else {
 147                 thisVal = this->GetClusterDist();
 148                 thatVal = that->GetClusterDist();
 149         }
 150
 151         if (thisVal > thatVal) return 1;
 152         else if (thisVal < thatVal) return -1;
 153         else return 0;
 154 }
 155 //
 156 //------------------------------------------------------------------------------
 157 //
 158 Bool_t AliEMCALTrack::PropagateTo(Double_t xk, Double_t d, Double_t x0)
 159 {
 160         //
 161         // Propagates a track to the plane defined by x='xk'.
 162         // Second parameter is the width (in units of rad. length) crossed by the track.
 163         // Third parameter is the reference radiation length used.
 164         // Track propagation includes computing energy loss (modifies curvature)
 165         // and multiple scattering perturbation (alters covariance matrix), if requested.
 166         // Method returns kFALSE when something goes wrong with computations.
 167         //
 168         // An additional operation (thanks to Yuri Belikov) is done to check
 169         // when the track crosses a sector boundary. If this happens,
 170         // the local track reference frame is adjusted accordingly.
 171         //
 172
 173         Double_t y=0.;
 174         Double_t field = GetBz();
 175         Double_t width = TMath::Pi() / 9.0; // width of TPC/TRD/EMCAL sector (= 20 deg)
 176         Double_t ymax  = TMath::Abs(xk * TMath::Tan(0.5 * width)); // max allowed Y in local coords at distance xk
 177
 178         // first check: try to compute the local 'y' at the distance 'xk':
 179         // if this attempt fails, the propagation cannot be done
 180         if (!GetYAt(xk, field, y)) return kFALSE;
 181
 182         // if is -ymax < y < ymax ==> 'direct' propagation is done;
 183         if (TMath::Abs(y) <= ymax) return SimplePropagation(xk, d, x0);
 184
 185         // otherwise, try change a sector to find one where the propagation is ok
 186         Int_t    i=0, incr=0, istart=0, nloops=0;
 187         Double_t alpha = GetAlpha();
 188         incr = (y > ymax) ? 1 : -1;
 189         if (alpha < 0.0) alpha += TMath::TwoPi();
 190         istart = (Int_t)(alpha / width);
 191         for (i = istart, nloops = 0; nloops < 18; i += incr, nloops++) {
 192                 if (i == 18) i = 0;
 193                 if (i == -1) i = 17;
 194                 alpha = ((Double_t)i + 0.5) * width;
 195                 if (Rotate(alpha)) {
 196                         if (GetYAt(xk, field, y)) {
 197                                 if (TMath::Abs(y) <= ymax) {
 198                                   AliDebug(1,Form("Required change from sector %d to sector %d to succeed in propagation", istart, i));
 199                                         return SimplePropagation(xk, d, x0);
 200                                 }
 201                         }
 202                 }
 203         }
 204
 205         // if the routine exits from the loop and reaches this point,
 206         // it means that none of the rotations succeeded
 207         AliWarning("Track propagation fails in every sector. Impossible to propagate.");
 208         return kFALSE;
 209 }
 210 //
 211 //------------------------------------------------------------------------------
 212 //
 213 Double_t AliEMCALTrack::StraightPropagateTo(Double_t xk, Double_t &x, Double_t &y, Double_t &z)
 214 {
 215         //
 216         // Does propagation with a straight line approximation.
 217         // This operation does not update track parameters, but it returns a point
 218         // in space, according to this propagation, which is stored in
 219         // the arguments #2, #3 and #4
 220         //
 221
 222         Double_t oldX = GetX(), oldY = GetY(), oldZ = GetZ();
 223         Double_t newPos[3];
 224
 225         newPos[0] = xk;
 226         newPos[1] = oldY * xk / oldX;
 227         newPos[2] = oldZ * xk / oldX;
 228
 229         Double_t cs = TMath::Cos(GetAlpha()), sn = TMath::Sin(GetAlpha());
 230         x = newPos[0]*cs - newPos[1]*sn;
 231         y = newPos[0]*sn + newPos[1]*cs;
 232         z = newPos[2];
 233
 234         return newPos[1];
 235 }
 236 //
 237 //------------------------------------------------------------------------------
 238 //
 239 Bool_t AliEMCALTrack::PropagateToGlobal(Double_t x, Double_t y, Double_t z, Double_t d, Double_t x0)
 240 {
 241         //
 242         // Propagate to a point specified with its global XYZ coordinates.
 243         // Here, the correct value of the 'X' parameter to be sent to "PropagateTo" is computed.
 244         //
 245
 246         TVector3 vc(x, y, z);
 247         Double_t width = 20.0; // width of TPC/TRD/EMCAL sector
 248         Double_t phi   = vc.Phi() * TMath::RadToDeg();
 249         if (phi < 0.0) phi += 360.0;
 250
 251         Int_t    isector = (Int_t)(phi / width);
 252         Double_t rotation = ((Double_t)isector + 0.5) * width;
 253         vc.RotateZ(-rotation * TMath::DegToRad());
 254
 255         return PropagateTo(vc.X(), d, x0);
 256 }
 257 //
 258 //------------------------------------------------------------------------------
 259 //
 260 Bool_t AliEMCALTrack::SimplePropagation(Double_t xk, Double_t d, Double_t x0)
 261 {
 262   //
 263   // Recall base class method for track propagation.
 264   //
 265
 266   Double_t field[3];
 267
 268   GetBxByBz(field);
 269
 270   // propagation...
 271   if (!AliExternalTrackParam::PropagateToBxByBz(xk, field)) return kFALSE;
 272
 273   // EL correction is computed only if requested...
 274   if (!fgCorrectForEL) return kTRUE;
 275   return AliExternalTrackParam::CorrectForMeanMaterial(d, x0, GetMass());
 276 }