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 /* $Id$ */
  17
  18 #include <Riostream.h>
  19
  20 #include <TMath.h>
  21 #include <TRandom.h>
  22 #include <TVector.h>
  23 #include <TGeometry.h>
  24 #include <TNode.h>
  25 #include <TTUBE.h>
  26 #include "TParticle.h"
  27
  28 #include "AliRun.h"
  29 #include "AliITS.h"
  30 #include "AliITSgeom.h"
  31 #include "AliITShit.h"
  32 #include "AliMC.h"
  33
  34
  35 ClassImp(AliITShit)
  36 ////////////////////////////////////////////////////////////////////////
  37 // Version: 0
  38 // Written by Rene Brun, Federico Carminati, and Roberto Barbera
  39 //
  40 // Version: 1
  41 // Modified and documented by Bjorn S. Nilsen
  42 // July 11 1999
  43 //
  44 // AliITShit is the hit class for the ITS. Hits are the information
  45 // that comes from a Monte Carlo at each step as a particle mass through
  46 // sensitive detector elements as particles are transported through a
  47 // detector.
  48 //
  49 //Begin_Html
  50 /*
  51 <img src="picts/ITS/AliITShit_Class_Diagram.gif">
  52 </pre>
  53 <br clear=left>
  54 <font size=+2 color=red>
  55 <p>This show the relasionships between the ITS hit class and the rest of Aliroot.
  56 </font>
  57 <pre>
  58 */
  59 //End_Html
  60 ////////////////////////////////////////////////////////////////////////
  61 // Inline Member functions:
  62 //
  63 // AliITShit()
  64 //     The default creator of the AliITShit class.
  65 //
  66 // ~AliITShit()
  67 //     The default destructor of the AliITShit class.
  68 //
  69 // int GetTrack()
  70 //     See AliHit for a full description. Returns the track number fTrack
  71 // for this hit.
  72 //
  73 // SetTrack(int track)
  74 //     See AliHit for a full description. Sets the track number fTrack
  75 // for this hit.
  76 //
  77 // Int_t GetTrackStatus()
  78 //     Returns the value of the track status flag fStatus. This flag
  79 // indicates the track status at the time of creating this hit. It is
  80 // made up of the following 8 status bits from highest order to lowest
  81 // order bits
  82 // 0           :  IsTrackAlive():    IsTrackStop():IsTrackDisappeared():
  83 // IsTrackOut():IsTrackExiting():IsTrackEntering():IsTrackInside()     .
  84 // See AliMC for a description of these functions. If the function is
  85 // true then the bit is set to one, otherwise it is zero.
  86 //
  87 // Bool_t StatusInside()
  88 //     Returns kTRUE if the particle producing this hit is still inside
  89 // the present volume. Returns kFalse if this particle will be in another
  90 // volume. {bit IsTrackInside is set or not}
  91 //
  92 // Bool_t StatusEntering()
  93 //     Returns kTRUE if the particle producing this hit is has just enterd
  94 // the present volume. Returns kFalse otherwise.  {bit IsTrackEntering is
  95 // set or not}
  96 //
  97 // Bool_t StatusExiting()
  98 //     Returns kTRUE if the particle producing this hit is will exit
  99 // the present volume. Returns kFalse otherwise. {bit IsTrackExiting is set
 100 // or not}
 101 //
 102 // Bool_t StatusOut()
 103 //     Returns kTRUE if the particle producing this hit is goint exit the
 104 // simulation. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 105 //
 106 // Bool_t StatusDisappeared()
 107 //     Returns kTRUE if the particle producing this hit is going to "disappear"
 108 // for example it has interacted producing some other particles. Returns
 109 //  kFalse otherwise. {bit IsTrackOut is set or not}
 110 //
 111 // Bool_t StatusStop()
 112 //     Returns kTRUE if the particle producing this hit is has dropped below
 113 // its energy cut off producing some other particles. Returns kFalse otherwise.
 114 // {bit IsTrackOut is set or not}
 115 //
 116 // Bool_t StatuAlives()
 117 //     Returns kTRUE if the particle producing this hit is going to continue
 118 // to be transported. Returns kFalse otherwise. {bit IsTrackOut is set or not}
 119 //
 120 // Int_t GetLayer()
 121 //     Returns the layer number, fLayer, for this hit.
 122 //
 123 // Int_t GetLadder()
 124 //     Returns the ladder number, fLadder, for this hit.
 125 //
 126 // Int_t GetDetector()
 127 //     Returns the detector number, fDet, for this hit.
 128 //
 129 // GetDetectorID(Int_t &layer, Int_t &ladder, Int_t &detector)
 130 //     Returns the layer, ladder, and detector numbers, fLayer fLadder fDet,
 131 // in one call.
 132 //
 133 // Float_t GetIonization()
 134 //     Returns the energy lost, fDestep, by the particle creating this hit,
 135 // in the units defined by the Monte Carlo.
 136 //
 137 // GetPositionG(Float_t &x, Float_t &y, Float_t &z)
 138 //     Returns the global position, fX fY fZ, of this hit, in the units
 139 // define by the Monte Carlo.
 140 //
 141 // GetPositionG(Double_t &x, Double_t &y, Double_t &z)
 142 //     Returns the global position, fX fY fZ, of this hit, in the units
 143 // define by the Monte Carlo.
 144 //
 145 // GetPositionG(Float_t &x, Float_t &y, Float_t &z, Float_t &tof)
 146 //     Returns the global position and time of flight, fX fY fZ fTof, of
 147 // this hit, in the units define by the Monte Carlo.
 148 //
 149 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 150 //     Returns the global position and time of flight, fX fY fZ fTof, of
 151 // this hit, in the units define by the Monte Carlo.
 152 //
 153 // GetPositionL(Double_t &x,Double_t &y,Double_t &z)
 154 //     Returns the local position, fX fY fZ, of this hit in the coordiante
 155 // of this module, in the units define by the Monte Carlo.
 156 //
 157 // GetPositionG(Double_t &x,Double_t &y,Double_t &z,Double_t &tof)
 158 //     Returns the local position and time of flight, fX fY fZ fTof, of
 159 // this hit in the coordinates of this module, in the units define by the
 160 //  Monte Carlo.
 161 //
 162 // Float_t GetXG()
 163 //     Returns the global x position in the units defined by the Monte Carlo.
 164 //
 165 // Float_t GetYG()
 166 //     Returns the global y position in the units defined by the Monte Carlo.
 167 //
 168 // Float_t GetYG()
 169 //     Returns the global z position in the units defined by the Monte Carlo.
 170 //
 171 // Float_t GetTOF()
 172 //     Returns the time of flight, fTof, of this hit, in the units defined
 173 // by the Monte Carlo.
 174 //
 175 // GetMomentumG(Float_t &px, Float_t &py, Float_t &pz)
 176 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 177 // this hit, in the units define by the Monte Carlo.
 178 //
 179 // GetMomentumG(Double_t &px,Double_t &py,Double_t &pz)
 180 //     Returns the global momentum, fPx fPy fPz, of the particle that made
 181 // this hit, in the units define by the Monte Carlo.
 182 //
 183 // GetMomentumL(Double_t &px,Double_t &py,Double_t &pz)
 184 //     Returns the momentum, fPx fPy fPz in coordinate appropreate for this
 185 // specific module, in the units define by the Monte Carlo.
 186 //
 187 // Float_t GetPXG()
 188 //     Returns the global X momentum in the units defined by the Monte Carlo.
 189 //
 190 // Float_t GetPYG()
 191 //     Returns the global Y momentum in the units defined by the Monte Carlo.
 192 //
 193 // Float_t GetPZG()
 194 //     Returns the global Z momentum in the units defined by the Monte Carlo.
 195 //
 196 ////////////////////////////////////////////////////////////////////////
 197 //_____________________________________________________________________________
 198 AliITShit::AliITShit():AliHit(){
 199     // Default Constructor
 200     // Zero data member just to be safe.
 201     // Intputs:
 202     //    none.
 203     // Outputs:
 204     //    none.
 205     // Return:
 206     //    A default created AliITShit class.
 207
 208     fStatus = 0; // Track Status
 209     fLayer  = 0;  // Layer number
 210     fLadder = 0; // Ladder number
 211     fDet    = 0;    // Detector number
 212     fPx     = 0.0;     // PX of particle at the point of the hit
 213     fPy     = 0.0;     // PY of particle at the point of the hit
 214     fPz     = 0.0;     // PZ of particle at the point of the hit
 215     fDestep = 0.0; // Energy deposited in the current step
 216     fTof    = 0.0;    // Time of flight at the point of the hit
 217     fStatus0 = 0; // zero status bit by default.
 218     fx0     = 0.0;     // Starting point of this step
 219     fy0     = 0.0;     // Starting point of this step
 220     fz0     = 0.0;     // Starting point of this step
 221     ft0     = 0.0;     // Starting point of this step
 222 }
 223 AliITShit::AliITShit(Int_t shunt,Int_t track,Int_t *vol,Float_t edep,
 224                      Float_t tof,TLorentzVector &x,TLorentzVector &x0,
 225                      TLorentzVector &p) : AliHit(shunt, track){
 226 ////////////////////////////////////////////////////////////////////////
 227 // Create ITS hit
 228 //     The creator of the AliITShit class. The variables shunt and
 229 // track are passed to the creator of the AliHit class. See the AliHit
 230 // class for a full description. In the units of the Monte Carlo
 231 ////////////////////////////////////////////////////////////////////////
 232     // Intputs:
 233     //    Int_t shunt   See AliHit
 234     //    Int_t track   Track number, see AliHit
 235     //    Int_t *vol     Array of integer hit data,
 236     //                     vol[0] Layer where the hit is, 1-6 typicaly
 237     //                     vol[1] Ladder where the hit is.
 238     //                     vol[2] Detector number where the hit is
 239     //                     vol[3] Set of status bits
 240     //                     vol[4] Set of status bits at start
 241     // Outputs:
 242     //    none.
 243     // Return:
 244     //    A default created AliITShit class.
 245
 246     fLayer      = vol[0];  // Layer number
 247     fLadder     = vol[2];  // Ladder number
 248     fDet        = vol[1];  // Detector number
 249     fStatus     = vol[3];  // Track status flags
 250     fStatus0    = vol[4];  // Track status flag for start position.
 251     fX          = x.X();   // Track X global position
 252     fY          = x.Y();   // Track Y global position
 253     fZ          = x.Z();   // Track Z global position
 254     fPx         = p.Px();  // Track X Momentum
 255     fPy         = p.Py();  // Track Y Momentum
 256     fPz         = p.Pz();  // Track Z Momentum
 257     fDestep     = edep;    // Track dE/dx for this step
 258     fTof        = tof   ;  // Track Time of Flight for this step
 259     fx0         = x0.X();  // Track X global position
 260     fy0         = x0.Y();  // Track Y global position
 261     fz0         = x0.Z();  // Track Z global position
 262     ft0         = x0.T();     // Starting point of this step
 263 }
 264 //______________________________________________________________________
 265 AliITShit::AliITShit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
 266     AliHit(shunt, track){
 267 ////////////////////////////////////////////////////////////////////////
 268 // Create ITS hit
 269 //     The creator of the AliITShit class. The variables shunt and
 270 // track are passed to the creator of the AliHit class. See the AliHit
 271 // class for a full description. the integer array *vol contains, in order,
 272 // fLayer = vol[0], fDet = vol[1], fLadder = vol[2], fStatus = vol[3].
 273 // The array *hits contains, in order, fX = hits[0], fY = hits[1],
 274 // fZ = hits[2], fPx = hits[3], fPy = hits[4], fPz = hits[5],
 275 // fDestep = hits[6], and fTof = hits[7]. In the units of the Monte Carlo
 276 ////////////////////////////////////////////////////////////////////////
 277     // Intputs:
 278     //    Int_t shunt   See AliHit
 279     //    Int_t track   Track number, see AliHit
 280     //    Int_t *vol     Array of integer hit data,
 281     //                     vol[0] Layer where the hit is, 1-6 typicaly
 282     //                     vol[1] Ladder where the hit is.
 283     //                     vol[2] Detector number where the hit is
 284     //                     vol[3] Set of status bits
 285     //    Float_t *hits   Array of hit information
 286     //                     hits[0] X global position of this hit
 287     //                     hits[1] Y global position of this hit
 288     //                     hits[2] Z global position of this hit
 289     //                     hits[3] Px global position of this hit
 290     //                     hits[4] Py global position of this hit
 291     //                     hits[5] Pz global position of this hit
 292     //                     hits[6] Energy deposited by this step
 293     //                     hits[7] Time of flight of this particle at this step
 294     // Outputs:
 295     //    none.
 296     // Return:
 297     //    A standard created AliITShit class.
 298   fLayer      = vol[0];   // Layer number
 299   fLadder     = vol[2];   // Ladder number
 300   fDet        = vol[1];   // Detector number
 301   fStatus     = vol[3];   // Track status flags
 302   fX          = hits[0];  // Track X global position
 303   fY          = hits[1];  // Track Y global position
 304   fZ          = hits[2];  // Track Z global position
 305   fPx         = hits[3];  // Track X Momentum
 306   fPy         = hits[4];  // Track Y Momentum
 307   fPz         = hits[5];  // Track Z Momentum
 308   fDestep     = hits[6];  // Track dE/dx for this step
 309   fTof        = hits[7];  // Track Time of Flight for this step
 310   fStatus0 = 0;// Track Status of Starting point
 311   fx0 = 0.0;     // Starting point of this step
 312   fy0 = 0.0;     // Starting point of this step
 313   fz0 = 0.0;     // Starting point of this step
 314   ft0 = 0.0;     // Starting point of this step
 315 }
 316 //______________________________________________________________________
 317 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z){
 318 ////////////////////////////////////////////////////////////////////////
 319 //     Returns the position of this hit in the local coordinates of this
 320 // module, and in the units of the Monte Carlo.
 321 ////////////////////////////////////////////////////////////////////////
 322     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 323     Float_t g[3],l[3];
 324
 325     g[0] = fX;
 326     g[1] = fY;
 327     g[2] = fZ;
 328     if(gm) {
 329       gm->GtoL(fLayer,fLadder,fDet,g,l);
 330       x = l[0];
 331       y = l[1];
 332       z = l[2];
 333     } else {
 334       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 335       // AliITSv7 - SDD case
 336       x=fX;
 337       y=fY;
 338       z=fZ;
 339     }
 340     return;
 341 }
 342 //______________________________________________________________________
 343 void AliITShit::GetPositionL(Float_t &x,Float_t &y,Float_t &z,Float_t &tof){
 344 ////////////////////////////////////////////////////////////////////////
 345 //     Returns the position and time of flight of this hit in the local
 346 // coordinates of this module, and in the units of the Monte Carlo.
 347 ////////////////////////////////////////////////////////////////////////
 348     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 349     Float_t g[3],l[3];
 350
 351     g[0] = fX;
 352     g[1] = fY;
 353     g[2] = fZ;
 354     if(gm) {
 355       gm->GtoL(fLayer,fLadder,fDet,g,l);
 356       x = l[0];
 357       y = l[1];
 358       z = l[2];
 359     } else {
 360       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 361       // AliITSv7 - SDD case
 362       x=fX;
 363       y=fY;
 364       z=fZ;
 365     }
 366     tof = fTof;
 367     return;
 368 }
 369 //______________________________________________________________________
 370 void AliITShit::GetPositionL0(Double_t &x,Double_t &y,Double_t &z,
 371                               Double_t &tof){
 372 ////////////////////////////////////////////////////////////////////////
 373 //     Returns the initial position and time of flight of this hit in the local
 374 // coordinates of this module, and in the units of the Monte Carlo.
 375 ////////////////////////////////////////////////////////////////////////
 376     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 377     Float_t g[3],l[3];
 378
 379     g[0] = fx0;
 380     g[1] = fy0;
 381     g[2] = fz0;
 382     if(gm) {
 383       gm->GtoL(fLayer,fLadder,fDet,g,l);
 384       x = l[0];
 385       y = l[1];
 386       z = l[2];
 387     } else {
 388       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 389       // AliITSv7 - SDD case
 390       x=fx0;
 391       y=fy0;
 392       z=fz0;
 393     }
 394     tof = ft0;
 395     return;
 396 }
 397 //______________________________________________________________________
 398 Float_t AliITShit::GetXL(){
 399 ////////////////////////////////////////////////////////////////////////
 400 //     Returns the x position of this hit in the local coordinates of this
 401 // module, and in the units of the Monte Carlo.
 402 ////////////////////////////////////////////////////////////////////////
 403     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 404     Float_t g[3],l[3];
 405
 406     g[0] = fX;
 407     g[1] = fY;
 408     g[2] = fZ;
 409     if(gm) {
 410       gm->GtoL(fLayer,fLadder,fDet,g,l);
 411       return l[0];
 412     } else {
 413       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 414       return fX;
 415     }
 416 }
 417 //______________________________________________________________________
 418 Float_t AliITShit::GetYL(){
 419 ////////////////////////////////////////////////////////////////////////
 420 //     Returns the y position of this hit in the local coordinates of this
 421 // module, and in the units of the Monte Carlo.
 422 ////////////////////////////////////////////////////////////////////////
 423     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 424     Float_t g[3],l[3];
 425
 426     g[0] = fX;
 427     g[1] = fY;
 428     g[2] = fZ;
 429     if (gm) {
 430       gm->GtoL(fLayer,fLadder,fDet,g,l);
 431       return l[1];
 432     } else {
 433       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 434       return fZ;
 435     }
 436 }
 437 //______________________________________________________________________
 438 Float_t AliITShit::GetZL(){
 439 ////////////////////////////////////////////////////////////////////////
 440 //     Returns the z position 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] = fX;
 447     g[1] = fY;
 448     g[2] = fZ;
 449     if(gm) {
 450       gm->GtoL(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 fY;
 455     }
 456 }
 457 //______________________________________________________________________
 458 void AliITShit::GetMomentumL(Float_t &px,Float_t &py,Float_t &pz){
 459 ////////////////////////////////////////////////////////////////////////
 460 //     Returns the momentum of this hit in the local coordinates of this
 461 // module, and in the units of the Monte Carlo.
 462 ////////////////////////////////////////////////////////////////////////
 463     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 464     Float_t g[3],l[3];
 465
 466     g[0] = fPx;
 467     g[1] = fPy;
 468     g[2] = fPz;
 469     if (gm) {
 470       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 471       px = l[0];
 472       py = l[1];
 473       pz = l[2];
 474     } else {
 475       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 476       px=fPx;
 477       py=fPy;
 478       pz=fPz;
 479     }
 480     return;
 481 }
 482 //______________________________________________________________________
 483 Float_t AliITShit::GetPXL(){
 484 ////////////////////////////////////////////////////////////////////////
 485 //     Returns the X momentum of this hit in the local coordinates of this
 486 // module, and in the units of the Monte Carlo.
 487 ////////////////////////////////////////////////////////////////////////
 488     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 489     Float_t g[3],l[3];
 490
 491     g[0] = fPx;
 492     g[1] = fPy;
 493     g[2] = fPz;
 494     if (gm) {
 495       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 496       return l[0];
 497     } else {
 498       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 499       return fPx;
 500     }
 501 }
 502 //______________________________________________________________________
 503 Float_t AliITShit::GetPYL(){
 504 ////////////////////////////////////////////////////////////////////////
 505 //     Returns the Y momentum of this hit in the local coordinates of this
 506 // module, and in the units of the Monte Carlo.
 507 ////////////////////////////////////////////////////////////////////////
 508     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 509     Float_t g[3],l[3];
 510
 511     g[0] = fPx;
 512     g[1] = fPy;
 513     g[2] = fPz;
 514     if (gm) {
 515       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 516       return l[1];
 517     } else {
 518       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 519       return fPy;
 520     }
 521
 522 }
 523 //______________________________________________________________________
 524 Float_t AliITShit::GetPZL(){
 525 ////////////////////////////////////////////////////////////////////////
 526 //     Returns the Z momentum of this hit in the local coordinates of this
 527 // module, and in the units of the Monte Carlo.
 528 ////////////////////////////////////////////////////////////////////////
 529     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 530     Float_t g[3],l[3];
 531
 532     g[0] = fPx;
 533     g[1] = fPy;
 534     g[2] = fPz;
 535     if (gm) {
 536       gm->GtoLMomentum(fLayer,fLadder,fDet,g,l);
 537       return l[2];
 538     } else {
 539       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 540       return fPz;
 541     }
 542
 543 }
 544 //___________________________________________________________________________;
 545 Int_t AliITShit::GetModule(){
 546 ////////////////////////////////////////////////////////////////////////
 547 //     Returns the module index number of the module where this hit was in.
 548 ////////////////////////////////////////////////////////////////////////
 549     AliITSgeom *gm = ((AliITS*)gAlice->GetDetector("ITS"))->GetITSgeom();
 550
 551     if (gm) return gm->GetModuleIndex(fLayer,fLadder,fDet);
 552     else {
 553       Error("AliITShit","NULL pointer to the geometry! return smth else",gm);
 554       return 0;
 555     }
 556 }
 557 //______________________________________________________________________
 558 TParticle * AliITShit::GetParticle(){
 559 ////////////////////////////////////////////////////////////////////////
 560 //     Returns the pointer to the TParticle for the particle that created
 561 // this hit. From the TParticle all kinds of information about this
 562 // particle can be found. See the TParticle class.
 563 ////////////////////////////////////////////////////////////////////////
 564     return gAlice->GetMCApp()->Particle(GetTrack());
 565 }
 566 //----------------------------------------------------------------------
 567 void AliITShit::Print(ostream *os){
 568 ////////////////////////////////////////////////////////////////////////
 569 // Standard output format for this class.
 570 ////////////////////////////////////////////////////////////////////////
 571 #if defined __GNUC__
 572 #if __GNUC__ > 2
 573     ios::fmtflags fmt;
 574 #else
 575     Int_t fmt;
 576 #endif
 577 #else
 578 #if defined __ICC || defined __ECC
 579     ios::fmtflags fmt;
 580 #else
 581     Int_t fmt;
 582 #endif
 583 #endif
 584
 585     fmt = os->setf(ios::scientific);  // set scientific floating point output
 586     *os << fTrack << " " << fX << " " << fY << " " << fZ << " ";
 587     fmt = os->setf(ios::hex); // set hex for fStatus only.
 588     *os << fStatus << " ";
 589     fmt = os->setf(ios::dec); // every thing else decimel.
 590     *os << fLayer << " " << fLadder << " " << fDet << " ";;
 591     *os << fPx << " " << fPy << " " << fPz << " ";
 592     *os << fDestep << " " << fTof;
 593     *os << " " << fx0 << " " << fy0 << " " << fz0;
 594 //    *os << " " << endl;
 595     os->flags(fmt); // reset back to old formating.
 596     return;
 597 }
 598 //----------------------------------------------------------------------
 599 void AliITShit::Read(istream *is){
 600 ////////////////////////////////////////////////////////////////////////
 601 // Standard input format for this class.
 602 ////////////////////////////////////////////////////////////////////////
 603
 604
 605     *is >> fTrack >> fX >> fY >> fZ;
 606     *is >> fStatus >> fLayer >> fLadder >> fDet >> fPx >> fPy >> fPz >>
 607            fDestep >> fTof;
 608     *is >> fx0 >> fy0 >> fz0;
 609     return;
 610 }
 611 //----------------------------------------------------------------------
 612 ostream &operator<<(ostream &os,AliITShit &p){
 613 ////////////////////////////////////////////////////////////////////////
 614 // Standard output streaming function.
 615 ////////////////////////////////////////////////////////////////////////
 616
 617     p.Print(&os);
 618     return os;
 619 }
 620 //----------------------------------------------------------------------
 621 istream &operator>>(istream &is,AliITShit &r){
 622 ////////////////////////////////////////////////////////////////////////
 623 // Standard input streaming function.
 624 ////////////////////////////////////////////////////////////////////////
 625
 626     r.Read(&is);
 627     return is;
 628 }
 629 //----------------------------------------------------------------------