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.13  2002/03/09 18:35:35  nilsen
  19 Added functions to print out Hit data members.
  20
  21 Revision 1.12  2002/03/08 16:05:05  nilsen
  22 Standeard io streamers added to make debugging et al. easier.
  23
  24 Revision 1.11  2001/01/30 09:23:13  hristov
  25 Streamers removed (R.Brun)
  26
  27 Revision 1.10  2001/01/26 20:01:19  hristov
  28 Major upgrade of AliRoot code
  29
  30 Revision 1.9  2000/10/02 16:32:51  barbera
  31 Automatic streamer used and forward declarations added
  32
  33 Revision 1.3.4.7  2000/10/02 15:54:49  barbera
  34 Automatic streamer used and forward declarations added
  35
  36 Revision 1.8  2000/09/22 12:35:21  nilsen
  37 Traps placed incase it is used without a properly initilized AliITSgeom class.
  38
  39 Revision 1.7  2000/07/10 16:07:18  fca
  40 Release version of ITS code
  41
  42 Revision 1.3.4.2  2000/03/04 23:43:57  nilsen
  43 Fixed up the comments/documentation.
  44
  45 Revision 1.3.4.1  2000/01/12 19:03:32  nilsen
  46 This is the version of the files after the merging done in December 1999.
  47 See the ReadMe110100.txt file for details
  48
  49 Revision 1.3  1999/09/29 09:24:20  fca
  50 Introduction of the Copyright and cvs Log
  51
  52 */
  53
  54 #include <iostream.h>
  55
  56 #include <TMath.h>
  57 #include <TRandom.h>
  58 #include <TVector.h>
  59 #include <TGeometry.h>
  60 #include <TNode.h>
  61 #include <TTUBE.h>
  62 #include "TParticle.h"
  63
  64 #include "AliRun.h"
  65 #include "AliITS.h"
  66 #include "AliITSgeom.h"
  67 #include "AliITShit.h"
  68
  69
  70 ClassImp(AliITShit)
  71 ////////////////////////////////////////////////////////////////////////
  72 // Version: 0
  73 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  74 //
  75 // Version: 1
  76 // Modified and documented by Bjorn S. Nilsen
  77 // July 11 1999
  78 //
  79 // AliITShit is the hit class for the ITS. Hits are the information
  80 // that comes from a Monte Carlo at each step as a particle mass through
  81 // sensitive detector elements as particles are transported through a
  82 // detector.
  83 //
  84 //Begin_Html
  85 /*
  86 <img src="picts/ITS/AliITShit_Class_Diagram.gif">
  87 </pre>
  88 <br clear=left>
  89 <font size=+2 color=red>
  90 <p>This show the relasionships between the ITS hit class and the rest of Aliroot.
  91 </font>
  92 <pre>
  93 */
  94 //End_Html
  95 ////////////////////////////////////////////////////////////////////////
  96 // Inline Member functions:
  97 //
  98 // AliITShit()
  99 //     The default creator of the AliITShit class.
 100 //
 101 // ~AliITShit()
 102 //     The default destructor of the AliITShit class.
 103 //
 104 // int GetTrack()
 105 //     See AliHit for a full description. Returns the track number fTrack
 106 // for this hit.
 107 //
 108 // SetTrack(int track)
 109 //     See AliHit for a full description. Sets the track number fTrack
 110 // for this hit.
 111 //
 112 // Int_t GetTrackStatus()
 113 //     Returns the value of the track status flag fStatus. This flag
 114 // indicates the track status at the time of creating this hit. It is
 115 // made up of the following 8 status bits from highest order to lowest
 116 // order bits
 117 // 0           :  IsTrackAlive():    IsTrackStop():IsTrackDisappeared():
 118 // IsTrackOut():IsTrackExiting():IsTrackEntering():IsTrackInside()     .
 119 // See AliMC for a description of these functions. If the function is
 120 // true then the bit is set to one, otherwise it is zero.
 121 //
 122 // Bool_t StatusInside()
 123 //     Returns kTRUE if the particle producing this hit is still inside
 124 // the present volume. Returns kFalse if this particle will be in another
 125 // volume. {bit IsTrackInside is set or not}
 126 //
 127 // Bool_t StatusEntering()
 128 //     Returns kTRUE if the particle producing this hit is has just enterd
 129 // the present volume. Returns kFalse otherwise.  {bit IsTrackEntering is
 130 // set or not}
 131 //
 132 // Bool_t StatusExiting()
 133 //     Returns kTRUE if the particle producing this hit is will exit
 134 // the present volume. Returns kFalse otherwise. {bit IsTrackExiting is set
 135 // or not}
 136 //
 137 // Bool_t StatusOut()
 138 //     Returns kTRUE if the particle producing this hit is goint exit the
 139 // simulation. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 140 //
 141 // Bool_t StatusDisappeared()
 142 //     Returns kTRUE if the particle producing this hit is going to "disappear"
 143 // for example it has interacted producing some other particles. Returns
 144 //  kFalse otherwise. {bit IsTrackOut is set or not}
 145 //
 146 // Bool_t StatusStop()
 147 //     Returns kTRUE if the particle producing this hit is has dropped below
 148 // its energy cut off producing some other particles. Returns kFalse otherwise.
 149 // {bit IsTrackOut is set or not}
 150 //
 151 // Bool_t StatuAlives()
 152 //     Returns kTRUE if the particle producing this hit is going to continue
 153 // to be transported. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 154 //
 155 // Int_t GetLayer()
 156 //     Returns the layer number, fLayer, for this hit.
 157 //
 158 // Int_t GetLadder()
 159 //     Returns the ladder number, fLadder, for this hit.
 160 //
 161 // Int_t GetDetector()
 162 //     Returns the detector number, fDet, for this hit.
 163 //
 164 // GetDetectorID(Int_t &layer, Int_t &ladder, Int_t &detector)
 165 //     Returns the layer, ladder, and detector numbers, fLayer fLadder fDet,
 166 // in one call.
 167 //
 168 // Float_t GetIonization()
 169 //     Returns the energy lost, fDestep, by the particle creating this hit,
 170 // in the units defined by the Monte Carlo.
 171 //
 172 // GetPositionG(Float_t &x, Float_t &y, Float_t &z)
 173 //     Returns the global position, fX fY fZ, of this hit, in the units
 174 // define by the Monte Carlo.
 175 //
 176 // GetPositionG(Double_t &x, Double_t &y, Double_t &z)
 177 //     Returns the global position, fX fY fZ, of this hit, in the units
 178 // define by the Monte Carlo.
 179 //
 180 // GetPositionG(Float_t &x, Float_t &y, Float_t &z, Float_t &tof)
 181 //     Returns the global position and time of flight, fX fY fZ fTof, of
 182 // this hit, in the units define by the Monte Carlo.
 183 //
 184 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 185 //     Returns the global position and time of flight, fX fY fZ fTof, of
 186 // this hit, in the units define by the Monte Carlo.
 187 //
 188 // GetPositionL(Double_t &x,Double_t &y,Double_t &z)
 189 //     Returns the local position, fX fY fZ, of this hit in the coordiante
 190 // of this module, in the units define by the Monte Carlo.
 191 //
 192 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 193 //     Returns the local position and time of flight, fX fY fZ fTof, of
 194 // this hit in the coordinates of this module, in the units define by the
 195 //  Monte Carlo.
 196 //
 197 // Float_t GetXG()
 198 //     Returns the global x position in the units defined by the Monte Carlo.
 199 //
 200 // Float_t GetYG()
 201 //     Returns the global y position in the units defined by the Monte Carlo.
 202 //
 203 // Float_t GetYG()
 204 //     Returns the global z position in the units defined by the Monte Carlo.
 205 //
 206 // Float_t GetTOF()
 207 //     Returns the time of flight, fTof, of this hit, in the units defined
 208 // by the Monte Carlo.
 209 //
 210 // GetMomentumG(Float_t &px, Float_t &py, Float_t &pz)
 211 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 212 // this hit, in the units define by the Monte Carlo.
 213 //
 214 // GetMomentumG(Double_t &px,Double_t &py,Double_t &pz)
 215 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 216 // this hit, in the units define by the Monte Carlo.
 217 //
 218 // GetMomentumL(Double_t &px,Double_t &py,Double_t &pz)
 219 //     Returns the momentum, fPx fPy fPz in coordinate appropreate for this
 220 // specific module, in the units define by the Monte Carlo.
 221 //
 222 // Float_t GetPXG()
 223 //     Returns the global X momentum in the units defined by the Monte Carlo.
 224 //
 225 // Float_t GetPYG()
 226 //     Returns the global Y momentum in the units defined by the Monte Carlo.
 227 //
 228 // Float_t GetPZG()
 229 //     Returns the global Z momentum in the units defined by the Monte Carlo.
 230 //
 231 ////////////////////////////////////////////////////////////////////////
 232 //_____________________________________________________________________________
 233 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
 234     AliHit(shunt, track){
 235 ////////////////////////////////////////////////////////////////////////
 236 // Create ITS hit
 237 //     The creator of the AliITShit class. The variables shunt and
 238 // track are passed to the creator of the AliHit class. See the AliHit
 239 // class for a full description. the integer array *vol contains, in order,
 240 // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
 241 // The array *hits contains, in order, fX = hits[0], fY = hits[1],
 242 // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
 243 // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
 244 ////////////////////////////////////////////////////////////////////////
 245   fLayer      = vol[0];   // Layer number
 246   fLadder     = vol[2];   // Ladder number
 247   fDet        = vol[1];   // Detector number
 248   fStatus     = vol[3];   // Track status flags
 249   fX          = hits[0];  // Track X position
 250   fY          = hits[1];  // Track Y position
 251   fZ          = hits[2];  // Track Z position
 252   fPx         = hits[3];  // Track X Momentum
 253   fPy         = hits[4];  // Track Y Momentum
 254   fPz         = hits[5];  // Track Z Momentum
 255   fDestep     = hits[6];  // Track dE/dx for this step
 256   fTof        = hits[7];  // Track Time of Flight for this step
 257 }
 258 //______________________________________________________________________
 259 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
 260 ////////////////////////////////////////////////////////////////////////
 261 //     Returns the position of this hit in the local coordinates of this
 262 // module, and in the units of the Monte Carlo.
 263 ////////////////////////////////////////////////////////////////////////
 264     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 265     Float_t g[3],l[3];
 266
 267     g[0] = fX;
 268     g[1] = fY;
 269     g[2] = fZ;
 270     if(gm) {
 271       gm->GtoL(fLayer,fLadder,fDet,g,l);
 272       x = l[0];
 273       y = l[1];
 274       z = l[2];
 275     } else {
 276       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 277       // AliITSv7 - SDD case
 278       x=fX;
 279       y=fZ;
 280       z=fY;
 281     }
 282     return;
 283 }
 284 //______________________________________________________________________
 285 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
 286 ////////////////////////////////////////////////////////////////////////
 287 //     Returns the position and time of flight of this hit in the local
 288 // coordinates of this 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     if(gm) {
 297       gm->GtoL(fLayer,fLadder,fDet,g,l);
 298       x = l[0];
 299       y = l[1];
 300       z = l[2];
 301     } else {
 302       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 303       // AliITSv7 - SDD case
 304       x=fX;
 305       y=fZ;
 306       z=fY;
 307     }
 308     tof = fTof;
 309     return;
 310 }
 311 //______________________________________________________________________
 312 Float_t AliITShit::GetXL(){
 313 ////////////////////////////////////////////////////////////////////////
 314 //     Returns the x position of this hit in the local coordinates of this
 315 // module, and in the units of the Monte Carlo.
 316 ////////////////////////////////////////////////////////////////////////
 317     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 318     Float_t g[3],l[3];
 319
 320     g[0] = fX;
 321     g[1] = fY;
 322     g[2] = fZ;
 323     if(gm) {
 324       gm->GtoL(fLayer,fLadder,fDet,g,l);
 325       return l[0];
 326     } else {
 327       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 328       return fX;
 329     }
 330 }
 331 //______________________________________________________________________
 332 Float_t AliITShit::GetYL(){
 333 ////////////////////////////////////////////////////////////////////////
 334 //     Returns the y position of this hit in the local coordinates of this
 335 // module, and in the units of the Monte Carlo.
 336 ////////////////////////////////////////////////////////////////////////
 337     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 338     Float_t g[3],l[3];
 339
 340     g[0] = fX;
 341     g[1] = fY;
 342     g[2] = fZ;
 343     if (gm) {
 344       gm->GtoL(fLayer,fLadder,fDet,g,l);
 345       return l[1];
 346     } else {
 347       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 348       return fZ;
 349     }
 350 }
 351 //______________________________________________________________________
 352 Float_t AliITShit::GetZL(){
 353 ////////////////////////////////////////////////////////////////////////
 354 //     Returns the z position of this hit in the local coordinates of this
 355 // module, and in the units of the Monte Carlo.
 356 ////////////////////////////////////////////////////////////////////////
 357     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 358     Float_t g[3],l[3];
 359
 360     g[0] = fX;
 361     g[1] = fY;
 362     g[2] = fZ;
 363     if(gm) {
 364       gm->GtoL(fLayer,fLadder,fDet,g,l);
 365       return l[2];
 366     } else {
 367       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 368       return fY;
 369     }
 370 }
 371 //______________________________________________________________________
 372 void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
 373 ////////////////////////////////////////////////////////////////////////
 374 //     Returns the momentum of this hit in the local coordinates of this
 375 // module, and in the units of the Monte Carlo.
 376 ////////////////////////////////////////////////////////////////////////
 377     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 378     Float_t g[3],l[3];
 379
 380     g[0] = fPx;
 381     g[1] = fPy;
 382     g[2] = fPz;
 383     if (gm) {
 384       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 385       px = l[0];
 386       py = l[1];
 387       pz = l[2];
 388     } else {
 389       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 390       px=fPx;
 391       py=fPy;
 392       pz=fPz;
 393     }
 394     return;
 395 }
 396 //______________________________________________________________________
 397 Float_t AliITShit::GetPXL(){
 398 ////////////////////////////////////////////////////////////////////////
 399 //     Returns the X momentum of this hit in the local coordinates of this
 400 // module, and in the units of the Monte Carlo.
 401 ////////////////////////////////////////////////////////////////////////
 402     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 403     Float_t g[3],l[3];
 404
 405     g[0] = fPx;
 406     g[1] = fPy;
 407     g[2] = fPz;
 408     if (gm) {
 409       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 410       return l[0];
 411     } else {
 412       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 413       return fPx;
 414     }
 415 }
 416 //______________________________________________________________________
 417 Float_t AliITShit::GetPYL(){
 418 ////////////////////////////////////////////////////////////////////////
 419 //     Returns the Y momentum of this hit in the local coordinates of this
 420 // module, and in the units of the Monte Carlo.
 421 ////////////////////////////////////////////////////////////////////////
 422     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 423     Float_t g[3],l[3];
 424
 425     g[0] = fPx;
 426     g[1] = fPy;
 427     g[2] = fPz;
 428     if (gm) {
 429       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 430       return l[1];
 431     } else {
 432       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 433       return fPy;
 434     }
 435
 436 }
 437 //______________________________________________________________________
 438 Float_t AliITShit::GetPZL(){
 439 ////////////////////////////////////////////////////////////////////////
 440 //     Returns the Z momentum of this hit in the local coordinates of this
 441 // module, and in the units of the Monte Carlo.
 442 ////////////////////////////////////////////////////////////////////////
 443     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 444     Float_t g[3],l[3];
 445
 446     g[0] = fPx;
 447     g[1] = fPy;
 448     g[2] = fPz;
 449     if (gm) {
 450       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 451       return l[2];
 452     } else {
 453       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 454       return fPz;
 455     }
 456
 457 }
 458 //___________________________________________________________________________;
 459 Int_t AliITShit::GetModule(){
 460 ////////////////////////////////////////////////////////////////////////
 461 //     Returns the module index number of the module where this hit was in.
 462 ////////////////////////////////////////////////////////////////////////
 463     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 464
 465     if (gm) return gm->GetModuleIndex(fLayer,fLadder,fDet);
 466     else {
 467       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 468       return 0;
 469     }
 470 }
 471 //______________________________________________________________________
 472 TParticle * AliITShit::GetParticle(){
 473 ////////////////////////////////////////////////////////////////////////
 474 //     Returns the pointer to the TParticle for the particle that created
 475 // this hit. From the TParticle all kinds of information about this
 476 // particle can be found. See the TParticle class.
 477 ////////////////////////////////////////////////////////////////////////
 478     return gAlice->Particle(GetTrack());
 479 }
 480 //----------------------------------------------------------------------
 481 void AliITShit::Print(ostream *os){
 482 ////////////////////////////////////////////////////////////////////////
 483 // Standard output format for this class.
 484 ////////////////////////////////////////////////////////////////////////
 485 #if defined __GNUC__
 486 #if __GNUC__ > 2
 487     ios::fmtflags fmt;
 488 #else
 489     Int_t fmt;
 490 #endif
 491 #else
 492 #if defined __ICC
 493     ios::fmtflags fmt;
 494 #else
 495     Int_t fmt;
 496 #endif
 497 #endif
 498
 499     fmt = os->setf(ios::scientific);  // set scientific floating point output
 500     *os << fTrack << " " << fX << " " << fY << " " << fZ << " ";
 501     fmt = os->setf(ios::hex); // set hex for fStatus only.
 502     *os << fStatus << " ";
 503     fmt = os->setf(ios::dec); // every thing else decimel.
 504     *os << fLayer << " " << fLadder << " " << fDet << " ";;
 505     *os << fPx << " " << fPy << " " << fPz << " ";
 506     *os << fDestep << " " << fTof;
 507     *os << endl;
 508     os->flags(fmt); // reset back to old formating.
 509     return;
 510 }
 511 //----------------------------------------------------------------------
 512 void AliITShit::Read(istream *is){
 513 ////////////////////////////////////////////////////////////////////////
 514 // Standard input format for this class.
 515 ////////////////////////////////////////////////////////////////////////
 516
 517
 518     *is >> fTrack >> fX >> fY >> fZ;
 519     *is >> fStatus >> fLayer >> fLadder >> fDet >> fPx >> fPy >> fPz >>
 520            fDestep >> fTof;
 521     return;
 522 }
 523 //----------------------------------------------------------------------
 524 ostream &operator<<(ostream &os,AliITShit &p){
 525 ////////////////////////////////////////////////////////////////////////
 526 // Standard output streaming function.
 527 ////////////////////////////////////////////////////////////////////////
 528
 529     p.Print(&os);
 530     return os;
 531 }
 532 //----------------------------------------------------------------------
 533 istream &operator>>(istream &is,AliITShit &r){
 534 ////////////////////////////////////////////////////////////////////////
 535 // Standard input streaming function.
 536 ////////////////////////////////////////////////////////////////////////
 537
 538     r.Read(&is);
 539     return is;
 540 }
 541 //----------------------------------------------------------------------