TRD/AliTRDrecPoint.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 /*
  17 $Log$
  18 Revision 1.7  2001/12/05 15:04:34  hristov
  19 Changes related to the corrections of AliRecPoint
  20
  21 Revision 1.6  2001/02/14 18:22:26  cblume
  22 Change in the geometry of the padplane
  23
  24 Revision 1.5  2000/11/14 14:40:27  cblume
  25 Correction for the Sun compiler (kTRUE and kFALSE)
  26
  27 Revision 1.4  2000/11/01 14:53:21  cblume
  28 Merge with TRD-develop
  29
  30 Revision 1.1.4.2  2000/10/04 16:34:58  cblume
  31 Replace include files by forward declarations
  32
  33 Revision 1.1.4.1  2000/09/22 14:50:39  cblume
  34 Adapted to tracking code
  35
  36 Revision 1.3  2000/06/09 11:10:07  cblume
  37 Compiler warnings and coding conventions, next round
  38
  39 Revision 1.2  2000/06/08 18:32:58  cblume
  40 Make code compliant to coding conventions
  41
  42 Revision 1.1  2000/02/28 19:02:07  cblume
  43 Add new TRD classes
  44
  45 */
  46
  47 ///////////////////////////////////////////////////////////////////////////////
  48 //                                                                           //
  49 //  TRD reconstructed point                                                  //
  50 //                                                                           //
  51 ///////////////////////////////////////////////////////////////////////////////
  52
  53 #include "AliRun.h"
  54
  55 #include "AliTRDgeometry.h"
  56 #include "AliTRDrecPoint.h"
  57 #include "AliTRD.h"
  58
  59 ClassImp(AliTRDrecPoint)
  60
  61 //_____________________________________________________________________________
  62 AliTRDrecPoint::AliTRDrecPoint():AliRecPoint()
  63 {
  64   //
  65   // Standard constructor
  66   //
  67
  68   fDetector = 0;
  69
  70   AliTRD *trd;
  71   if ((gAlice) &&
  72       (trd = ((AliTRD*) gAlice->GetDetector("TRD")))) {
  73     fGeom = trd->GetGeometry();
  74   }
  75   else {
  76     fGeom = NULL;
  77   }
  78
  79 }
  80
  81 //_____________________________________________________________________________
  82 AliTRDrecPoint::AliTRDrecPoint(const char * opt):AliRecPoint(opt)
  83 {
  84   //
  85   // Standard constructor
  86   //
  87
  88   fDetector = 0;
  89
  90   AliTRD *trd;
  91   if ((gAlice) &&
  92       (trd = ((AliTRD*) gAlice->GetDetector("TRD")))) {
  93     fGeom = trd->GetGeometry();
  94   }
  95   else {
  96     fGeom = NULL;
  97   }
  98
  99 }
 100
 101 //_____________________________________________________________________________
 102 AliTRDrecPoint::~AliTRDrecPoint()
 103 {
 104   //
 105   // AliTRDrecPoint destructor
 106   //
 107
 108 }
 109
 110 //_____________________________________________________________________________
 111 void AliTRDrecPoint::AddDigit(Int_t digit)
 112 {
 113   //
 114   // Adds the index of a digit to the digits list
 115   //
 116
 117   // First resize the list
 118   // (no clusters with more than 3 digits for the TRD
 119   if ((fMulDigit == 0) && (fMaxDigit >= 5)) {
 120     fMaxDigit = 5;
 121     delete fDigitsList;
 122     fDigitsList = new int[fMaxDigit];
 123   }
 124
 125   // Increase the size of the list if necessary
 126   if (fMulDigit >= fMaxDigit) {
 127     fMaxDigit *= 2;
 128     int *tempo = new (int[fMaxDigit]);
 129     Int_t index;
 130     for (index = 0; index < fMulDigit; index++)
 131       tempo[index] = fDigitsList[index];
 132     delete fDigitsList;
 133     fDigitsList = tempo;
 134   }
 135
 136   fDigitsList[fMulDigit++] = digit;
 137
 138 }
 139
 140 //_____________________________________________________________________________
 141 void AliTRDrecPoint::SetLocalPosition(TVector3 &pos)
 142 {
 143   //
 144   // Sets the position of the point in the local coordinate system
 145   // (row,col,time) and calculates the error matrix in the same
 146   // system.
 147   //
 148
 149   const Float_t kSq12 = 3.464101615;
 150
 151   // Set the position
 152   fLocPos = pos;
 153
 154   // Set the error matrix
 155   // row:  pad-size / sqrt(12)
 156   // col:  not defined yet
 157   // time: bin-size / sqrt(12)
 158   Int_t plane   = ((AliTRDgeometry *) fGeom)->GetPlane(fDetector);
 159   Int_t chamber = ((AliTRDgeometry *) fGeom)->GetChamber(fDetector);
 160   Int_t sector  = ((AliTRDgeometry *) fGeom)->GetSector(fDetector);
 161   fLocPosM->operator()(0,0) = ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane
 162                                                                        ,chamber
 163                                                                        ,sector)
 164                             / kSq12;
 165   fLocPosM->operator()(1,1) = 0.0;
 166   fLocPosM->operator()(2,2) = ((AliTRDgeometry *) fGeom)->GetTimeBinSize()
 167                             / kSq12;
 168
 169   //  printf("rec. point: row = %f, col = %f, time = %f \n",
 170   //           fLocPos[0],fLocPos[1],fLocPos[2]);
 171
 172 }
 173
 174 //_____________________________________________________________________________
 175 void AliTRDrecPoint::SetTrackingYZ(Float_t sigmaY, Float_t sigmaZ)
 176 {
 177  //
 178  // Sets the position of the point in the local coordinate system
 179  // of tracking sector
 180  //
 181
 182  Int_t plane = ((AliTRDgeometry *) fGeom)->GetPlane(fDetector);
 183  Int_t chamber = ((AliTRDgeometry *) fGeom)->GetChamber(fDetector);
 184  Int_t sector = ((AliTRDgeometry *) fGeom)->GetSector(fDetector);
 185
 186
 187  // Set the position
 188
 189   Float_t   padRow    = fLocPos[0];             // Pad Row position
 190   Float_t   padCol    = fLocPos[1];             // Pad Column position
 191
 192   Float_t   col0 = ((AliTRDgeometry *) fGeom)->GetCol0(plane);
 193   Float_t   row0 = ((AliTRDgeometry *) fGeom)->GetRow0(plane,chamber,sector);
 194
 195   //  Float_t   offset = 0.5 * ((AliTRDgeometry *) fGeom)->GetChamberWidth(plane);
 196
 197   fY = - (col0 + padCol * ((AliTRDgeometry *) fGeom)->GetColPadSize(plane));
 198   fZ =    row0 + padRow * ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane
 199                                                                    ,chamber
 200                                                                    ,sector);
 201
 202   //  fSigmaY = sigmaY * sigmaY;
 203   //  fSigmaZ = sigmaZ * sigmaZ;
 204
 205   fSigmaY2 = 0.05 * 0.05;
 206
 207   fSigmaZ2 = ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane,chamber,sector)
 208            * ((AliTRDgeometry *) fGeom)->GetRowPadSize(plane,chamber,sector)
 209            / 12.;
 210
 211 }
 212
 213 //_____________________________________________________________________________
 214 void AliTRDrecPoint::AddTrackIndex(Int_t *track)
 215 {
 216  // Adds track index. Currently assumed that track is an array of
 217  // size 9, and up to 3 track indexes are stored in fTracks[3].
 218  // Indexes are sorted according to:
 219  //  1) index of max number of appearances is stored first
 220  //  2) if two or more indexes appear equal number of times, the lowest
 221  //     ones are stored first;
 222
 223   const Int_t kSize = 9;
 224
 225   Int_t entries[kSize][2], i, j, index;
 226
 227   Bool_t indexAdded;
 228
 229   for (i=0; i<kSize; i++) {
 230     entries[i][0]=-1;
 231     entries[i][1]=0;
 232   }
 233
 234
 235   for (Int_t k=0; k<kSize; k++) {
 236     index=track[k];
 237     indexAdded=kFALSE; j=0;
 238     if (index >= 0) {
 239       while ( (!indexAdded) && ( j < kSize ) ) {
 240         if ((entries[j][0]==index) || (entries[j][1]==0)) {
 241           entries[j][0]=index;
 242           entries[j][1]=entries[j][1]+1;
 243           indexAdded=kTRUE;
 244         }
 245         j++;
 246       }
 247     }
 248   }
 249
 250   // sort by number of appearances and index value
 251   Int_t swap=1, tmp0, tmp1;
 252   while ( swap > 0) {
 253     swap=0;
 254     for(i=0; i<(kSize-1); i++) {
 255       if ((entries[i][0] >= 0) && (entries[i+1][0] >= 0)) {
 256         if ((entries[i][1] < entries[i+1][1]) ||
 257             ((entries[i][1] == entries[i+1][1]) &&
 258              (entries[i][0] > entries[i+1][0]))) {
 259                tmp0=entries[i][0];
 260                tmp1=entries[i][1];
 261                entries[i][0]=entries[i+1][0];
 262                entries[i][1]=entries[i+1][1];
 263                entries[i+1][0]=tmp0;
 264                entries[i+1][1]=tmp1;
 265                swap++;
 266         }
 267       }
 268     }
 269   }
 270
 271   // set track indexes
 272
 273   for(i=0; i<3; i++) {
 274     fTracks[i] = entries[i][0];
 275   }
 276
 277   return;
 278
 279 }