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()),
  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, x, 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 &t)
 117 {
 118         //
 119         // Assignment operator
 120         // Works like copy constructor
 121         //
 122
 123         fClusterIndex = t.fClusterIndex;
 124         fClusterDist = t.fClusterDist;
 125
 126         fMass = t.fMass;
 127
 128         fSeedIndex = t.fSeedIndex;
 129         fSeedLabel = t.fSeedLabel;
 130         return *this;
 131 }
 132 //
 133 //------------------------------------------------------------------------------
 134 //
 135 Int_t AliEMCALTrack::Compare(const TObject *obj) const
 136 {
 137         //
 138         // Compare tracks.
 139         // How tracks are compared depends on the static flag
 140         // "fSortByPt" (boolean):
 141         // true  => tracks are compared w.r. to their transverse momentum
 142         // false => tracks are compared w.r. to their distance from cluster
 143         //
 144
 145         AliEMCALTrack *that = (AliEMCALTrack*)obj;
 146
 147         Double_t thisP[3], thisVal, thatP[3], thatVal;
 148
 149         if (fgSortByPt) {
 150                 this->GetPxPyPz(thisP);
 151                 that->GetPxPyPz(thatP);
 152                 thisVal = TMath::Sqrt(thisP[0]*thisP[0] + thisP[1]*thisP[1]);
 153                 thatVal = TMath::Sqrt(thatP[0]*thatP[0] + thatP[1]*thatP[1]);
 154         }
 155         else {
 156                 thisVal = this->GetClusterDist();
 157                 thatVal = that->GetClusterDist();
 158         }
 159
 160         if (thisVal > thatVal) return 1;
 161         else if (thisVal < thatVal) return -1;
 162         else return 0;
 163 }
 164 //
 165 //------------------------------------------------------------------------------
 166 //
 167 Bool_t AliEMCALTrack::PropagateTo(Double_t xk, Double_t d, Double_t x0)
 168 {
 169         //
 170         // Propagates a track to the plane defined by x='xk'.
 171         // Second parameter is the width (in units of rad. length) crossed by the track.
 172         // Third parameter is the reference radiation length used.
 173         // Track propagation includes computing energy loss (modifies curvature)
 174         // and multiple scattering perturbation (alters covariance matrix), if requested.
 175         // Method returns kFALSE when something goes wrong with computations.
 176         //
 177         // An additional operation (thanks to Yuri Belikov) is done to check
 178         // when the track crosses a sector boundary. If this happens,
 179         // the local track reference frame is adjusted accordingly.
 180         //
 181
 182         Double_t y;
 183         Double_t field = GetBz();
 184         Double_t width = TMath::Pi() / 9.0; // width of TPC/TRD/EMCAL sector (= 20 deg)
 185         Double_t ymax  = TMath::Abs(xk * TMath::Tan(0.5 * width)); // max allowed Y in local coords at distance xk
 186
 187         // first check: try to compute the local 'y' at the distance 'xk':
 188         // if this attempt fails, the propagation cannot be done
 189         if (!GetYAt(xk, field, y)) return kFALSE;
 190
 191         // if is -ymax < y < ymax ==> 'direct' propagation is done;
 192         if (TMath::Abs(y) <= ymax) return SimplePropagation(xk, d, x0);
 193
 194         // otherwise, try change a sector to find one where the propagation is ok
 195         Int_t    i, incr, istart, nloops;
 196         Double_t alpha = GetAlpha();
 197         incr = (y > ymax) ? 1 : -1;
 198         if (alpha < 0.0) alpha += TMath::TwoPi();
 199         istart = (Int_t)(alpha / width);
 200         for (i = istart, nloops = 0; nloops < 18; i += incr, nloops++) {
 201                 if (i == 18) i = 0;
 202                 if (i == -1) i = 17;
 203                 alpha = ((Double_t)i + 0.5) * width;
 204                 if (Rotate(alpha)) {
 205                         if (GetYAt(xk, field, y)) {
 206                                 if (TMath::Abs(y) <= ymax) {
 207                                   AliDebug(1,Form("Required change from sector %d to sector %d to succeed in propagation", istart, i));
 208                                         return SimplePropagation(xk, d, x0);
 209                                 }
 210                         }
 211                 }
 212         }
 213
 214         // if the routine exits from the loop and reaches this point,
 215         // it means that none of the rotations succeeded
 216         AliWarning("Track propagation fails in every sector. Impossible to propagate.");
 217         return kFALSE;
 218 }
 219 //
 220 //------------------------------------------------------------------------------
 221 //
 222 Double_t AliEMCALTrack::StraightPropagateTo(Double_t xk, Double_t &x, Double_t &y, Double_t &z)
 223 {
 224         //
 225         // Does propagation with a straight line approximation.
 226         // This operation does not update track parameters, but it returns a point
 227         // in space, according to this propagation, which is stored in
 228         // the arguments #2, #3 and #4
 229         //
 230
 231         Double_t oldX = GetX(), oldY = GetY(), oldZ = GetZ();
 232         Double_t newPos[3];
 233
 234         newPos[0] = xk;
 235         newPos[1] = oldY * xk / oldX;
 236         newPos[2] = oldZ * xk / oldX;
 237
 238         Double_t cs = TMath::Cos(GetAlpha()), sn = TMath::Sin(GetAlpha());
 239         x = newPos[0]*cs - newPos[1]*sn;
 240         y = newPos[0]*sn + newPos[1]*cs;
 241         z = newPos[2];
 242
 243         return newPos[1];
 244 }
 245 //
 246 //------------------------------------------------------------------------------
 247 //
 248 Bool_t AliEMCALTrack::PropagateToGlobal(Double_t x, Double_t y, Double_t z, Double_t d, Double_t x0)
 249 {
 250         //
 251         // Propagate to a point specified with its global XYZ coordinates.
 252         // Here, the correct value of the 'X' parameter to be sent to "PropagateTo" is computed.
 253         //
 254
 255         TVector3 vc(x, y, z);
 256         Double_t width = 20.0; // width of TPC/TRD/EMCAL sector
 257         Double_t phi   = vc.Phi() * TMath::RadToDeg();
 258         if (phi < 0.0) phi += 360.0;
 259
 260         Int_t    isector = (Int_t)(phi / width);
 261         Double_t rotation = ((Double_t)isector + 0.5) * width;
 262         vc.RotateZ(-rotation * TMath::DegToRad());
 263
 264         return PropagateTo(vc.X(), d, x0);
 265 }
 266 //
 267 //------------------------------------------------------------------------------
 268 //
 269 Bool_t AliEMCALTrack::SimplePropagation(Double_t xk, Double_t d, Double_t x0)
 270 {
 271         //
 272         // Recall base class method for track propagation.
 273         //
 274
 275         Double_t field = GetBz();
 276
 277         // propagation...
 278         if (!AliExternalTrackParam::PropagateTo(xk, field)) return kFALSE;
 279
 280         // EL correction is computed only if requested...
 281         if (!fgCorrectForEL) return kTRUE;
 282         return AliExternalTrackParam::CorrectForMeanMaterial(d, x0, GetMass());
 283 }