ITS/AliITShit.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.3.4.2  2000/03/04 23:43:57  nilsen
  19 Fixed up the comments/documentation.
  20
  21 Revision 1.3.4.1  2000/01/12 19:03:32  nilsen
  22 This is the version of the files after the merging done in December 1999.
  23 See the ReadMe110100.txt file for details
  24
  25 Revision 1.3  1999/09/29 09:24:20  fca
  26 Introduction of the Copyright and cvs Log
  27
  28 */
  29
  30
  31 #include <TMath.h>
  32 #include <TRandom.h>
  33 #include <TVector.h>
  34 #include <TGeometry.h>
  35 #include <TNode.h>
  36 #include <TTUBE.h>
  37
  38 #include "AliRun.h"
  39 #include "AliITSgeom.h"
  40 #include "AliITS.h"
  41 #include "AliITShit.h"
  42
  43
  44 ClassImp(AliITShit)
  45 ////////////////////////////////////////////////////////////////////////
  46 // Version: 0
  47 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  48 //
  49 // Version: 1
  50 // Modified and documented by Bjorn S. Nilsen
  51 // July 11 1999
  52 //
  53 // AliITShit is the hit class for the ITS. Hits are the information
  54 // that comes from a Monte Carlo at each step as a particle mass through
  55 // sensitive detector elements as particles are transported through a
  56 // detector.
  57 //
  58 //Begin_Html
  59 /*
  60 <img src="picts/ITS/AliITShit_Class_Diagram.gif">
  61 </pre>
  62 <br clear=left>
  63 <font size=+2 color=red>
  64 <p>This show the relasionships between the ITS hit class and the rest of Aliroot.
  65 </font>
  66 <pre>
  67 */
  68 //End_Html
  69 ////////////////////////////////////////////////////////////////////////
  70 // Inline Member functions:
  71 //
  72 // AliITShit()
  73 //     The default creator of the AliITShit class.
  74 //
  75 // ~AliITShit()
  76 //     The default destructor of the AliITShit class.
  77 //
  78 // int GetTrack()
  79 //     See AliHit for a full description. Returns the track number fTrack
  80 // for this hit.
  81 //
  82 // SetTrack(int track)
  83 //     See AliHit for a full description. Sets the track number fTrack
  84 // for this hit.
  85 //
  86 // Int_t GetTrackStatus()
  87 //     Returns the value of the track status flag fStatus. This flag
  88 // indicates the track status at the time of creating this hit. It is
  89 // made up of the following 8 status bits from highest order to lowest
  90 // order bits
  91 // 0           :  IsTrackAlive():    IsTrackStop():IsTrackDisappeared():
  92 // IsTrackOut():IsTrackExiting():IsTrackEntering():IsTrackInside()     .
  93 // See AliMC for a description of these functions. If the function is
  94 // true then the bit is set to one, otherwise it is zero.
  95 //
  96 // Bool_t StatusInside()
  97 //     Returns kTRUE if the particle producing this hit is still inside
  98 // the present volume. Returns kFalse if this particle will be in another
  99 // volume. {bit IsTrackInside is set or not}
 100 //
 101 // Bool_t StatusEntering()
 102 //     Returns kTRUE if the particle producing this hit is has just enterd
 103 // the present volume. Returns kFalse otherwise.  {bit IsTrackEntering is
 104 // set or not}
 105 //
 106 // Bool_t StatusExiting()
 107 //     Returns kTRUE if the particle producing this hit is will exit
 108 // the present volume. Returns kFalse otherwise. {bit IsTrackExiting is set
 109 // or not}
 110 //
 111 // Bool_t StatusOut()
 112 //     Returns kTRUE if the particle producing this hit is goint exit the
 113 // simulation. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 114 //
 115 // Bool_t StatusDisappeared()
 116 //     Returns kTRUE if the particle producing this hit is going to "disappear"
 117 // for example it has interacted producing some other particles. Returns
 118 //  kFalse otherwise. {bit IsTrackOut is set or not}
 119 //
 120 // Bool_t StatusStop()
 121 //     Returns kTRUE if the particle producing this hit is has dropped below
 122 // its energy cut off producing some other particles. Returns kFalse otherwise.
 123 // {bit IsTrackOut is set or not}
 124 //
 125 // Bool_t StatuAlives()
 126 //     Returns kTRUE if the particle producing this hit is going to continue
 127 // to be transported. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 128 //
 129 // Int_t GetLayer()
 130 //     Returns the layer number, fLayer, for this hit.
 131 //
 132 // Int_t GetLadder()
 133 //     Returns the ladder number, fLadder, for this hit.
 134 //
 135 // Int_t GetDetector()
 136 //     Returns the detector number, fDet, for this hit.
 137 //
 138 // GetDetectorID(Int_t &layer, Int_t &ladder, Int_t &detector)
 139 //     Returns the layer, ladder, and detector numbers, fLayer fLadder fDet,
 140 // in one call.
 141 //
 142 // Float_t GetIonization()
 143 //     Returns the energy lost, fDestep, by the particle creating this hit,
 144 // in the units defined by the Monte Carlo.
 145 //
 146 // GetPositionG(Float_t &x, Float_t &y, Float_t &z)
 147 //     Returns the global position, fX fY fZ, of this hit, in the units
 148 // define by the Monte Carlo.
 149 //
 150 // GetPositionG(Double_t &x, Double_t &y, Double_t &z)
 151 //     Returns the global position, fX fY fZ, of this hit, in the units
 152 // define by the Monte Carlo.
 153 //
 154 // GetPositionG(Float_t &x, Float_t &y, Float_t &z, Float_t &tof)
 155 //     Returns the global position and time of flight, fX fY fZ fTof, of
 156 // this hit, in the units define by the Monte Carlo.
 157 //
 158 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 159 //     Returns the global position and time of flight, fX fY fZ fTof, of
 160 // this hit, in the units define by the Monte Carlo.
 161 //
 162 // GetPositionL(Double_t &x,Double_t &y,Double_t &z)
 163 //     Returns the local position, fX fY fZ, of this hit in the coordiante
 164 // of this module, in the units define by the Monte Carlo.
 165 //
 166 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 167 //     Returns the local position and time of flight, fX fY fZ fTof, of
 168 // this hit in the coordinates of this module, in the units define by the
 169 //  Monte Carlo.
 170 //
 171 // Float_t GetXG()
 172 //     Returns the global x position in the units defined by the Monte Carlo.
 173 //
 174 // Float_t GetYG()
 175 //     Returns the global y position in the units defined by the Monte Carlo.
 176 //
 177 // Float_t GetYG()
 178 //     Returns the global z position in the units defined by the Monte Carlo.
 179 //
 180 // Float_t GetTOF()
 181 //     Returns the time of flight, fTof, of this hit, in the units defined
 182 // by the Monte Carlo.
 183 //
 184 // GetMomentumG(Float_t &px, Float_t &py, Float_t &pz)
 185 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 186 // this hit, in the units define by the Monte Carlo.
 187 //
 188 // GetMomentumG(Double_t &px,Double_t &py,Double_t &pz)
 189 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 190 // this hit, in the units define by the Monte Carlo.
 191 //
 192 // GetMomentumL(Double_t &px,Double_t &py,Double_t &pz)
 193 //     Returns the momentum, fPx fPy fPz in coordinate appropreate for this
 194 // specific module, in the units define by the Monte Carlo.
 195 //
 196 // Float_t GetPXG()
 197 //     Returns the global X momentum in the units defined by the Monte Carlo.
 198 //
 199 // Float_t GetPYG()
 200 //     Returns the global Y momentum in the units defined by the Monte Carlo.
 201 //
 202 // Float_t GetPZG()
 203 //     Returns the global Z momentum in the units defined by the Monte Carlo.
 204 //
 205 ////////////////////////////////////////////////////////////////////////
 206 //_____________________________________________________________________________
 207 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
 208     AliHit(shunt, track){
 209 ////////////////////////////////////////////////////////////////////////
 210 // Create ITS hit
 211 //     The creator of the AliITShit class. The variables shunt and
 212 // track are passed to the creator of the AliHit class. See the AliHit
 213 // class for a full description. the integer array *vol contains, in order,
 214 // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
 215 // The array *hits contains, in order, fX = hits[0], fY = hits[1],
 216 // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
 217 // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
 218 ////////////////////////////////////////////////////////////////////////
 219   fLayer      = vol[0];   // Layer number
 220   fLadder     = vol[2];   // Ladder number
 221   fDet        = vol[1];   // Detector number
 222   fStatus     = vol[3];   // Track status flags
 223   fX          = hits[0];  // Track X position
 224   fY          = hits[1];  // Track Y position
 225   fZ          = hits[2];  // Track Z position
 226   fPx         = hits[3];  // Track X Momentum
 227   fPy         = hits[4];  // Track Y Momentum
 228   fPz         = hits[5];  // Track Z Momentum
 229   fDestep     = hits[6];  // Track dE/dx for this step
 230   fTof        = hits[7];  // Track Time of Flight for this step
 231 }
 232 //______________________________________________________________________
 233 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
 234 ////////////////////////////////////////////////////////////////////////
 235 //     Returns the position of this hit in the local coordinates of this
 236 // module, and in the units of the Monte Carlo.
 237 ////////////////////////////////////////////////////////////////////////
 238     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 239     Float_t g[3],l[3];
 240
 241     g[0] = fX;
 242     g[1] = fY;
 243     g[2] = fZ;
 244     gm->GtoL(fLayer,fLadder,fDet,g,l);
 245     x = l[0];
 246     y = l[1];
 247     z = l[2];
 248     return;
 249 }
 250 //______________________________________________________________________
 251 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
 252 ////////////////////////////////////////////////////////////////////////
 253 //     Returns the position and time of flight of this hit in the local
 254 // coordinates of this module, and in the units of the Monte Carlo.
 255 ////////////////////////////////////////////////////////////////////////
 256     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 257     Float_t g[3],l[3];
 258
 259     g[0] = fX;
 260     g[1] = fY;
 261     g[2] = fZ;
 262     gm->GtoL(fLayer,fLadder,fDet,g,l);
 263     x = l[0];
 264     y = l[1];
 265     z = l[2];
 266     tof = fTof;
 267     return;
 268 }
 269 //______________________________________________________________________
 270 Float_t AliITShit::GetXL(){
 271 ////////////////////////////////////////////////////////////////////////
 272 //     Returns the x position of this hit in the local coordinates of this
 273 // module, and in the units of the Monte Carlo.
 274 ////////////////////////////////////////////////////////////////////////
 275     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 276     Float_t g[3],l[3];
 277
 278     g[0] = fX;
 279     g[1] = fY;
 280     g[2] = fZ;
 281     gm->GtoL(fLayer,fLadder,fDet,g,l);
 282     return l[0];
 283 }
 284 //______________________________________________________________________
 285 Float_t AliITShit::GetYL(){
 286 ////////////////////////////////////////////////////////////////////////
 287 //     Returns the y position of this hit in the local coordinates of this
 288 // module, and in the units of the Monte Carlo.
 289 ////////////////////////////////////////////////////////////////////////
 290     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 291     Float_t g[3],l[3];
 292
 293     g[0] = fX;
 294     g[1] = fY;
 295     g[2] = fZ;
 296     gm->GtoL(fLayer,fLadder,fDet,g,l);
 297     return l[1];
 298 }
 299 //______________________________________________________________________
 300 Float_t AliITShit::GetZL(){
 301 ////////////////////////////////////////////////////////////////////////
 302 //     Returns the z position of this hit in the local coordinates of this
 303 // module, and in the units of the Monte Carlo.
 304 ////////////////////////////////////////////////////////////////////////
 305     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 306     Float_t g[3],l[3];
 307
 308     g[0] = fX;
 309     g[1] = fY;
 310     g[2] = fZ;
 311     gm->GtoL(fLayer,fLadder,fDet,g,l);
 312     return l[2];
 313 }
 314 //______________________________________________________________________
 315 void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
 316 ////////////////////////////////////////////////////////////////////////
 317 //     Returns the momentum of this hit in the local coordinates of this
 318 // module, and in the units of the Monte Carlo.
 319 ////////////////////////////////////////////////////////////////////////
 320     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 321     Float_t g[3],l[3];
 322
 323     g[0] = fPx;
 324     g[1] = fPy;
 325     g[2] = fPz;
 326     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 327     px = l[0];
 328     py = l[1];
 329     pz = l[2];
 330     return;
 331 }
 332 //______________________________________________________________________
 333 Float_t AliITShit::GetPXL(){
 334 ////////////////////////////////////////////////////////////////////////
 335 //     Returns the X momentum of this hit in the local coordinates of this
 336 // module, and in the units of the Monte Carlo.
 337 ////////////////////////////////////////////////////////////////////////
 338     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 339     Float_t g[3],l[3];
 340
 341     g[0] = fPx;
 342     g[1] = fPy;
 343     g[2] = fPz;
 344     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 345     return l[0];
 346 }
 347 //______________________________________________________________________
 348 Float_t AliITShit::GetPYL(){
 349 ////////////////////////////////////////////////////////////////////////
 350 //     Returns the Y momentum of this hit in the local coordinates of this
 351 // module, and in the units of the Monte Carlo.
 352 ////////////////////////////////////////////////////////////////////////
 353     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 354     Float_t g[3],l[3];
 355
 356     g[0] = fPx;
 357     g[1] = fPy;
 358     g[2] = fPz;
 359     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 360     return l[1];
 361 }
 362 //______________________________________________________________________
 363 Float_t AliITShit::GetPZL(){
 364 ////////////////////////////////////////////////////////////////////////
 365 //     Returns the Z momentum of this hit in the local coordinates of this
 366 // module, and in the units of the Monte Carlo.
 367 ////////////////////////////////////////////////////////////////////////
 368     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 369     Float_t g[3],l[3];
 370
 371     g[0] = fPx;
 372     g[1] = fPy;
 373     g[2] = fPz;
 374     gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 375     return l[2];
 376 }
 377 //___________________________________________________________________________;
 378 Int_t AliITShit::GetModule(){
 379 ////////////////////////////////////////////////////////////////////////
 380 //     Returns the module index number of the module where this hit was in.
 381 ////////////////////////////////////////////////////////////////////////
 382     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 383
 384     return gm->GetModuleIndex(fLayer,fLadder,fDet);
 385 }
 386 //______________________________________________________________________
 387 TParticle * AliITShit::GetParticle(){
 388 ////////////////////////////////////////////////////////////////////////
 389 //     Returns the pointer to the TParticle for the particle that created
 390 // this hit. From the TParticle all kinds of information about this
 391 // particle can be found. See the TParticle class.
 392 ////////////////////////////////////////////////////////////////////////
 393     TClonesArray *Parts = gAlice->Particles();
 394     return ((TParticle*)Parts->UncheckedAt(this->GetTrack()));
 395 }
 396 //___________________________________________________________________________
 397 void AliITShit::Streamer(TBuffer &R__b){
 398 ////////////////////////////////////////////////////////////////////////
 399 //     The streamer function for this AliITShit class. This has been set
 400 // up so that future changes to this class can be easly incorporated.
 401 ////////////////////////////////////////////////////////////////////////
 402    if (R__b.IsReading()) {
 403       Version_t R__v = R__b.ReadVersion();
 404       if (R__v==1) {
 405           AliHit::Streamer(R__b);
 406           R__b >> fStatus;
 407           R__b >> fLayer;
 408           R__b >> fLadder;
 409           R__b >> fDet;
 410           R__b >> fPx;
 411           R__b >> fPy;
 412           R__b >> fPz;
 413           R__b >> fDestep;
 414           R__b >> fTof;
 415       }else{ // for futrue changes to this class.
 416       } // end if R__v==1
 417    } else {
 418       R__b.WriteVersion(AliITShit::IsA());
 419       AliHit::Streamer(R__b);
 420       R__b << fStatus;
 421       R__b << fLayer;
 422       R__b << fLadder;
 423       R__b << fDet;
 424       R__b << fPx;
 425       R__b << fPy;
 426       R__b << fPz;
 427       R__b << fDestep;
 428       R__b << fTof;
 429    } // end if R__b.IsReading()
 430 }