ITS/AliITSv1.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.14.2.6  2000/06/12 19:14:32  barbera
  19 Remove partical transision to new Config.C calling convension. Bug Found.
  20
  21 Revision 1.14.2.5  2000/06/12 18:15:13  barbera
  22 fixed posible compilation errors on HP unix. Modifided default constructor
  23 for use with new calling requirements. Removed creation of hits from this
  24 cource geometry.
  25
  26 Revision 1.14.2.4  2000/06/11 20:37:26  barbera
  27 coding convenstion update.
  28
  29 Revision 1.14.2.2  2000/05/19 10:09:21  nilsen
  30 fix for bug with HP and Sun unix + fix for event display in ITS-working branch
  31
  32 Revision 1.14.2.1  2000/03/04 23:45:19  nilsen
  33 Fixed up the comments/documentation.
  34
  35 Revision 1.14  1999/11/25 06:52:56  fca
  36 Correct value of drca
  37
  38 Revision 1.13.2.1  1999/11/25 06:52:21  fca
  39 Correct value of drca
  40
  41 Revision 1.13  1999/10/27 11:16:26  fca
  42 Correction of problem in geometry
  43
  44 Revision 1.12  1999/10/22 08:25:25  fca
  45 remove double definition of destructors
  46
  47 Revision 1.11  1999/10/22 08:16:49  fca
  48 Correct destructors, thanks to I.Hrivnacova
  49
  50 Revision 1.10  1999/10/06 19:56:50  fca
  51 Add destructor
  52
  53 Revision 1.9  1999/10/05 08:05:09  fca
  54 Minor corrections for uninitialised variables.
  55
  56 Revision 1.8  1999/09/29 09:24:20  fca
  57 Introduction of the Copyright and cvs Log
  58
  59 */
  60
  61 ///////////////////////////////////////////////////////////////////////////////
  62 //                                                                           //
  63 //  Inner Traking System version 1                                           //
  64 //  This class contains the base procedures for the Inner Tracking System    //
  65 //                                                                           //
  66 // Authors: R. Barbera, A. Morsch.
  67 // version 1.
  68 // Created  1998.
  69 //
  70 //  NOTE: THIS IS THE COARSE pre.TDR geometry of the ITS. THIS WILL NOT WORK
  71 // with the geometry or module classes or any analysis classes. You are
  72 // strongly encouraged to uses AliITSv5.
  73 //                                                                           //
  74 ///////////////////////////////////////////////////////////////////////////////
  75
  76 #include <TMath.h>
  77 #include <TRandom.h>
  78 #include <TVector.h>
  79 #include <TGeometry.h>
  80 #include <TNode.h>
  81 #include <TTUBE.h>
  82 #include <TFile.h>    // only required for Tracking function?
  83 #include <TCanvas.h>
  84 #include <TObjArray.h>
  85 #include <TClonesArray.h>
  86
  87
  88 #include "AliMC.h"
  89 #include "AliConst.h"
  90
  91 #include "AliITShit.h"
  92 #include "AliITSv1.h"
  93 #include "AliRun.h"
  94
  95
  96 ClassImp(AliITSv1)
  97
  98 //_____________________________________________________________________________
  99   AliITSv1::AliITSv1()/*:AliITS("ITS","TDR cource version")*/ {
 100 ////////////////////////////////////////////////////////////////////////
 101 //    Standard default constructor for the ITS version 1.
 102 ////////////////////////////////////////////////////////////////////////
 103     fId1N = 6;
 104     fId1Name = new char*[fId1N];
 105     fId1Name[0] = "ITS1";
 106     fId1Name[1] = "ITS2";
 107     fId1Name[2] = "ITS3";
 108     fId1Name[3] = "ITS4";
 109     fId1Name[4] = "ITS5";
 110     fId1Name[5] = "ITS6";
 111     printf("Created ITS TDR Cource version\n");
 112 }
 113 //_____________________________________________________________________________
 114 AliITSv1::AliITSv1(const char *name, const char *title) : AliITS(name, title){
 115 ////////////////////////////////////////////////////////////////////////
 116 //    Standard constructor for the ITS version 1.
 117 ////////////////////////////////////////////////////////////////////////
 118     fId1N = 6;
 119     fId1Name = new char*[fId1N];
 120     fId1Name[0] = "ITS1";
 121     fId1Name[1] = "ITS2";
 122     fId1Name[2] = "ITS3";
 123     fId1Name[3] = "ITS4";
 124     fId1Name[4] = "ITS5";
 125     fId1Name[5] = "ITS6";
 126     printf("Created ITS TDR Cource version\n");
 127 }
 128 //____________________________________________________________________________
 129 AliITSv1::AliITSv1(const AliITSv1 &source){
 130 ////////////////////////////////////////////////////////////////////////
 131 //     Copy Constructor for ITS version 1.
 132 ////////////////////////////////////////////////////////////////////////
 133     if(&source == this) return;
 134     this->fId1N = source.fId1N;
 135     this->fId1Name = new char*[fId1N];
 136     Int_t i;
 137     for(i=0;i<6;i++) strcpy(this->fId1Name[i],source.fId1Name[i]);
 138     return;
 139 }
 140 //_____________________________________________________________________________
 141 AliITSv1& AliITSv1::operator=(const AliITSv1 &source){
 142 ////////////////////////////////////////////////////////////////////////
 143 //    Assignment operator for the ITS version 1.
 144 ////////////////////////////////////////////////////////////////////////
 145   if(&source == this) return *this;
 146   this->fId1N = source.fId1N;
 147   this->fId1Name = new char*[fId1N];
 148   Int_t i;
 149   for(i=0;i<6;i++) strcpy(this->fId1Name[i],source.fId1Name[i]);
 150   return *this;
 151 }
 152 //_____________________________________________________________________________
 153 AliITSv1::~AliITSv1() {
 154 ////////////////////////////////////////////////////////////////////////
 155 //    Standard destructor for the ITS version 1.
 156 ////////////////////////////////////////////////////////////////////////
 157   delete [] fId1Name;
 158 }//__________________________________________________________________________
 159 void AliITSv1::BuildGeometry(){
 160 ////////////////////////////////////////////////////////////////////////
 161 //    Geometry builder for the ITS version 1.
 162 ////////////////////////////////////////////////////////////////////////
 163     TNode *node, *top;
 164     const Int_t kColorITS=kYellow;
 165     //
 166     top = gAlice->GetGeometry()->GetNode("alice");
 167
 168     new TTUBE("S_layer1","Layer1 of ITS","void",3.9,3.9+0.05475,12.25);
 169     top->cd();
 170     node = new TNode("Layer1","Layer1","S_layer1",0,0,0,"");
 171     node->SetLineColor(kColorITS);
 172     fNodes->Add(node);
 173
 174     new TTUBE("S_layer2","Layer2 of ITS","void",7.6,7.6+0.05475,16.3);
 175     top->cd();
 176     node = new TNode("Layer2","Layer2","S_layer2",0,0,0,"");
 177     node->SetLineColor(kColorITS);
 178     fNodes->Add(node);
 179
 180     new TTUBE("S_layer3","Layer3 of ITS","void",14,14+0.05288,21.1);
 181     top->cd();
 182     node = new TNode("Layer3","Layer3","S_layer3",0,0,0,"");
 183     node->SetLineColor(kColorITS);
 184     fNodes->Add(node);
 185
 186     new TTUBE("S_layer4","Layer4 of ITS","void",24,24+0.05288,29.6);
 187     top->cd();
 188     node = new TNode("Layer4","Layer4","S_layer4",0,0,0,"");
 189     node->SetLineColor(kColorITS);
 190     fNodes->Add(node);
 191
 192     new TTUBE("S_layer5","Layer5 of ITS","void",40,40+0.05382,45.1);
 193     top->cd();
 194     node = new TNode("Layer5","Layer5","S_layer5",0,0,0,"");
 195     node->SetLineColor(kColorITS);
 196     fNodes->Add(node);
 197
 198     new TTUBE("S_layer6","Layer6 of ITS","void",45,45+0.05382,50.4);
 199     top->cd();
 200     node = new TNode("Layer6","Layer6","S_layer6",0,0,0,"");
 201     node->SetLineColor(kColorITS);
 202     fNodes->Add(node);
 203 }
 204 //_____________________________________________________________________________
 205 void AliITSv1::CreateGeometry(){
 206 ////////////////////////////////////////////////////////////////////////
 207 //    This routine defines and Creates the geometry for version 1 of the ITS.
 208 ////////////////////////////////////////////////////////////////////////
 209
 210   Float_t drcer[6] = { 0.,0.,.08,.08,0.,0. };           //CERAMICS THICKNESS
 211   Float_t drepx[6] = { 0.,0.,0.,0.,.5357,.5357 };       //EPOXY THICKNESS
 212   Float_t drpla[6] = { 0.,0.,0.,0.,.1786,.1786 };       //PLASTIC THICKNESS
 213   Float_t dzb[6]   = { 0.,0.,15.,15.,4.,4. };           //LENGTH OF BOXES
 214   Float_t dphi[6]  = { 72.,72.,72.,72.,50.6,45. };      //COVERED PHI-RANGE FOR LAYERS 1-6
 215   Float_t rl[6]    = { 3.9,7.6,14.,24.,40.,45. };       //SILICON LAYERS INNER RADIUS
 216   Float_t drl[6]   = { .755,.755,.809,.809,.7,.7 };     //THICKNESS OF LAYERS (in % radiation length)
 217   Float_t dzl[6]   = { 12.67,16.91,20.85,29.15,45.11,50.975 };//HALF LENGTH OF LAYERS
 218   Float_t drpcb[6] = { 0.,0.,.06,.06,0.,0. };           //PCB THICKNESS
 219   Float_t drcu[6]  = { 0.,0.,.0504,.0504,.0357,.0357 }; //COPPER THICKNESS
 220   Float_t drsi[6]  = { 0.,0.,.006,.006,.3571,.3571 };   //SILICON THICKNESS
 221
 222   Float_t drca, dzfc;
 223   Int_t i, nsec;
 224   Float_t rend, drcatpc, dzco, zend, dits[3], rlim, drsu, zmax;
 225   Float_t zpos, dzco1, dzco2;
 226   Float_t drcac[6], acone, dphii;
 227   Float_t pcits[15], xltpc;
 228   Float_t rzcone, rstep, r0, z0, acable, fp, dz, zi, ri;
 229   Int_t idrotm[399];
 230   Float_t dgh[15];
 231
 232   Int_t *idtmed = fIdtmed->GetArray()-199;
 233
 234   //     CONVERT INTO CM (RL(SI)=9.36 CM)
 235   for(i = 0; i < 6; ++i) {
 236     drl[i] = drl[i] / 100. * 9.36;
 237   }
 238
 239   //     SUPPORT ENDPLANE THICKNESS
 240   drsu = 2.*0.06+1./20;  // 1./20. is 1 cm of honeycomb (1/20 carbon density);
 241
 242   //     CONE BELOW TPC
 243
 244   drcatpc = 1.2/4.;
 245
 246   //     CABLE THICKNESS (CONICAL CABLES CONNECTING THE LAYERS)
 247
 248   drca = 0.2;
 249
 250   //     ITS CONE ANGLE
 251
 252   acone  = 45.;
 253   acone *= kDegrad;
 254
 255   //     CONE RADIUS AT 1ST LAYER
 256
 257   rzcone = 30.;
 258
 259   //     FIELD CAGE HALF LENGTH
 260
 261   dzfc  = 64.5;
 262   rlim  = 48.;
 263   zmax  = 80.;
 264   xltpc = 275.;
 265
 266
 267   //     PARAMETERS FOR SMALL (1/2) ITS
 268
 269   for(i = 0; i < 6; ++i) {
 270     dzl[i] /= 2.;
 271     dzb[i] /= 2.;
 272   }
 273   drca     /= 2.;
 274   acone    /= 2.;
 275   drcatpc /= 2.;
 276   rzcone   /= 2.;
 277   dzfc     /= 2.;
 278   zmax     /= 2.;
 279   xltpc    /= 2.;
 280   acable    = 15.;
 281
 282
 283
 284   //     EQUAL DISTRIBUTION INTO THE 6 LAYERS
 285   rstep = drcatpc / 6.;
 286   for(i = 0; i < 6; ++i) {
 287     drcac[i] = (i+1) * rstep;
 288   }
 289
 290   //     NUMBER OF PHI SECTORS
 291
 292   nsec = 5;
 293
 294   //     PACK IN PHI AS MUCH AS POSSIBLE
 295   //     NOW PACK USING THICKNESS
 296
 297   for(i = 0; i < 6; ++i) {
 298
 299 //     PACKING FACTOR
 300     fp = rl[5] / rl[i];
 301
 302     //      PHI-PACKING NOT SUFFICIENT ?
 303
 304     if (dphi[i]/45 < fp) {
 305       drcac[i] = drcac[i] * fp * 45/dphi[i];
 306     }
 307   }
 308
 309
 310   // --- Define ghost volume containing the six layers and fill it with air
 311
 312   dgh[0] = 3.5;
 313   dgh[1] = 50.;
 314   dgh[2] = zmax;
 315   gMC->Gsvolu("ITSV", "TUBE", idtmed[275], dgh, 3);
 316
 317   // --- Place the ghost volume in its mother volume (ALIC) and make it
 318   //     invisible
 319
 320   gMC->Gspos("ITSV", 1, "ALIC", 0., 0., 0., 0, "ONLY");
 321   gMC->Gsatt("ITSV", "SEEN", 0);
 322
 323   //     ITS LAYERS (SILICON)
 324
 325   dits[0] = rl[0];
 326   dits[1] = rl[0] + drl[0];
 327   dits[2] = dzl[0];
 328   gMC->Gsvolu("ITS1", "TUBE", idtmed[199], dits, 3);
 329   gMC->Gspos("ITS1", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 330
 331   dits[0] = rl[1];
 332   dits[1] = rl[1] + drl[1];
 333   dits[2] = dzl[1];
 334   gMC->Gsvolu("ITS2", "TUBE", idtmed[199], dits, 3);
 335   gMC->Gspos("ITS2", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 336
 337   dits[0] = rl[2];
 338   dits[1] = rl[2] + drl[2];
 339   dits[2] = dzl[2];
 340   gMC->Gsvolu("ITS3", "TUBE", idtmed[224], dits, 3);
 341   gMC->Gspos("ITS3", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 342
 343   dits[0] = rl[3];
 344   dits[1] = rl[3] + drl[3];
 345   dits[2] = dzl[3];
 346   gMC->Gsvolu("ITS4", "TUBE", idtmed[224], dits, 3);
 347   gMC->Gspos("ITS4", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 348
 349   dits[0] = rl[4];
 350   dits[1] = rl[4] + drl[4];
 351   dits[2] = dzl[4];
 352   gMC->Gsvolu("ITS5", "TUBE", idtmed[249], dits, 3);
 353   gMC->Gspos("ITS5", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 354
 355   dits[0] = rl[5];
 356   dits[1] = rl[5] + drl[5];
 357   dits[2] = dzl[5];
 358   gMC->Gsvolu("ITS6", "TUBE", idtmed[249], dits, 3);
 359   gMC->Gspos("ITS6", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 360
 361   //    ELECTRONICS BOXES
 362
 363   //     PCB (layer #3 and #4)
 364
 365   gMC->Gsvolu("IPCB", "TUBE", idtmed[233], dits, 0);
 366   for(i = 2; i < 4; ++i) {
 367     dits[0] = rl[i];
 368     dits[1] = dits[0] + drpcb[i];
 369     dits[2] = dzb[i] / 2.;
 370     zpos = dzl[i] + dits[2];
 371     gMC->Gsposp("IPCB", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 372     gMC->Gsposp("IPCB", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 373   }
 374
 375   //     COPPER (layer #3 and #4)
 376
 377   gMC->Gsvolu("ICO2", "TUBE", idtmed[234], dits, 0);
 378   for(i = 2; i < 4; ++i) {
 379     dits[0] = rl[i] + drpcb[i];
 380     dits[1] = dits[0] + drcu[i];
 381     dits[2] = dzb[i] / 2.;
 382     zpos = dzl[i] + dits[2];
 383     gMC->Gsposp("ICO2", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 384     gMC->Gsposp("ICO2", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 385   }
 386
 387   //     CERAMICS (layer #3 and #4)
 388
 389   gMC->Gsvolu("ICER", "TUBE", idtmed[235], dits, 0);
 390   for(i = 2; i < 4; ++i) {
 391     dits[0] = rl[i] + drpcb[i] + drcu[i];
 392     dits[1] = dits[0] + drcer[i];
 393     dits[2] = dzb[i] / 2.;
 394     zpos = dzl[i] + dits[2];
 395     gMC->Gsposp("ICER", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 396     gMC->Gsposp("ICER", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 397   }
 398
 399   //     SILICON (layer #3 and #4)
 400
 401   gMC->Gsvolu("ISI2", "TUBE", idtmed[226], dits, 0);
 402   for(i = 2; i < 4; ++i) {
 403     dits[0] = rl[i] + drpcb[i] + drcu[i] + drcer[i];
 404     dits[1] = dits[0] + drsi[i];
 405     dits[2] = dzb[i] / 2.;
 406     zpos = dzl[i] + dits[2];
 407     gMC->Gsposp("ISI2", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 408     gMC->Gsposp("ISI2", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 409   }
 410
 411   //     PLASTIC (G10FR4) (layer #5 and #6)
 412
 413   gMC->Gsvolu("IPLA", "TUBE", idtmed[262], dits, 0);
 414   for(i = 4; i < 6; ++i) {
 415     dits[0] = rl[i];
 416     dits[1] = dits[0] + drpla[i];
 417     dits[2] = dzb[i] / 2.;
 418     zpos = dzl[i] + dits[2];
 419     gMC->Gsposp("IPLA", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 420     gMC->Gsposp("IPLA", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 421   }
 422
 423   //     COPPER (layer #5 and #6)
 424
 425   gMC->Gsvolu("ICO3", "TUBE", idtmed[259], dits, 0);
 426   for(i = 4; i < 6; ++i) {
 427     dits[0] = rl[i] + drpla[i];
 428     dits[1] = dits[0] + drcu[i];
 429     dits[2] = dzb[i] / 2.;
 430     zpos = dzl[i] + dits[2];
 431     gMC->Gsposp("ICO3", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 432     gMC->Gsposp("ICO3", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 433   }
 434
 435   //     EPOXY (layer #5 and #6)
 436
 437   gMC->Gsvolu("IEPX", "TUBE", idtmed[262], dits, 0);
 438   for(i = 4; i < 6; ++i) {
 439     dits[0] = rl[i] + drpla[i] + drcu[i];
 440     dits[1] = dits[0] + drepx[i];
 441     dits[2] = dzb[i] / 2.;
 442     zpos = dzl[i] + dits[2];
 443     gMC->Gsposp("IEPX", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 444     gMC->Gsposp("IEPX", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 445   }
 446
 447   //     SILICON (layer #5 and #6)
 448
 449   gMC->Gsvolu("ISI3", "TUBE", idtmed[251], dits, 0);
 450   for(i = 4; i < 6; ++i) {
 451     dits[0] = rl[i] + drpla[i] + drcu[i] + drepx[i];
 452     dits[1] = dits[0] + drsi[i];
 453     dits[2] = dzb[i] / 2.;
 454     zpos = dzl[i] + dits[2];
 455     gMC->Gsposp("ISI3", i-1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 456     gMC->Gsposp("ISI3", i+1, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 457   }
 458
 459   //    SUPPORT
 460
 461   gMC->Gsvolu("ISUP", "TUBE", idtmed[274], dits, 0);
 462   for(i = 0; i < 6; ++i) {
 463     dits[0] = rl[i];
 464     if (i < 5) dits[1] = rl[i+1];
 465     else       dits[1] = rlim;
 466     dits[2] = drsu / 2.;
 467     zpos = dzl[i] + dzb[i] + dits[2];
 468     gMC->Gsposp("ISUP", i+1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 469     gMC->Gsposp("ISUP", i+7, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 470   }
 471
 472   // CABLES (HORIZONTAL)
 473
 474   gMC->Gsvolu("ICHO", "TUBE", idtmed[278], dits, 0);
 475   for(i = 0; i < 6; ++i) {
 476     dits[0] = rl[i];
 477     dits[1] = dits[0] + drca;
 478     dits[2] = (rzcone + TMath::Tan(acone) * (rl[i] - rl[0]) - (dzl[i]+ dzb[i] + drsu)) / 2.;
 479     zpos = dzl[i - 1] + dzb[i] + drsu + dits[2];
 480     gMC->Gsposp("ICHO", i+1, "ITSV", 0., 0., zpos, 0, "ONLY", dits, 3);
 481     gMC->Gsposp("ICHO", i+7, "ITSV", 0., 0.,-zpos, 0, "ONLY", dits, 3);
 482   }
 483   //    DEFINE A CONICAL GHOST VOLUME FOR THE PHI SEGMENTATION
 484   pcits[0] = 0.;
 485   pcits[1] = 360.;
 486   pcits[2] = 2.;
 487   pcits[3] = rzcone;
 488   pcits[4] = 3.5;
 489   pcits[5] = rl[0];
 490   pcits[6] = pcits[3] + TMath::Tan(acone) * (rlim - rl[0]);
 491   pcits[7] = rlim - rl[0] + 3.5;
 492   pcits[8] = rlim;
 493   gMC->Gsvolu("ICMO", "PCON", idtmed[275], pcits, 9);
 494   AliMatrix(idrotm[200], 90., 0., 90., 90., 180., 0.);
 495   gMC->Gspos("ICMO", 1, "ITSV", 0., 0., 0., 0, "ONLY");
 496   gMC->Gspos("ICMO", 2, "ITSV", 0., 0., 0., idrotm[200], "ONLY");
 497
 498   //     DIVIDE INTO NSEC PHI-SECTIONS
 499
 500   gMC->Gsdvn("ICMD", "ICMO", nsec, 2);
 501   gMC->Gsatt("ICMO", "SEEN", 0);
 502   gMC->Gsatt("ICMD", "SEEN", 0);
 503
 504   //     CONICAL CABLES
 505
 506   pcits[2] = 2.;
 507   gMC->Gsvolu("ICCO", "PCON", idtmed[278], pcits, 0);
 508   for(i = 1; i < 6; ++i) {
 509     pcits[0] = -dphi[i] / 2.;
 510     pcits[1] = dphi[i];
 511     if (i < 5) {
 512       dzco = TMath::Tan(acone) * (rl[i+1] - rl[i]);
 513     } else {
 514       dzco1 = zmax - (rzcone + TMath::Tan(acone) * (rl[5] - rl[0])) -2.;
 515       dzco2 = (rlim - rl[5]) * TMath::Tan(acone);
 516       if (rl[5] + dzco1 / TMath::Tan(acone) < rlim) {
 517         dzco = dzco1;
 518       } else {
 519         dzco = dzco2;
 520       }
 521     }
 522     pcits[3] = rzcone + TMath::Tan(acone) * (rl[i] - rl[0]);
 523     pcits[4] = rl[i] - drcac[i] / TMath::Sin(acone);
 524     pcits[5] = rl[i];
 525     pcits[6] = pcits[3] + dzco;
 526     pcits[7] = rl[i] + dzco / TMath::Tan(acone) - drcac[i] / TMath::Sin(acone);
 527     pcits[8] = rl[i] + dzco / TMath::Tan(acone);
 528
 529     gMC->Gsposp("ICCO", i, "ICMD", 0., 0., 0., 0, "ONLY", pcits, 9);
 530
 531   }
 532   zend = pcits[6];
 533   rend = pcits[8];
 534
 535   //  CONICAL CABLES BELOW TPC
 536
 537   //    DEFINE A CONICAL GHOST VOLUME FOR THE PHI SEGMENTATION
 538   pcits[0] = 0.;
 539   pcits[1] = 360.;
 540   pcits[2] = 2.;
 541   pcits[3] = zend;
 542   pcits[5] = rend;
 543   pcits[4] = pcits[5] - drcatpc;
 544   pcits[6] = xltpc;
 545   pcits[8] = pcits[4] + (pcits[6] - pcits[3]) * TMath::Tan(acable * kDegrad);
 546   pcits[7] = pcits[8] - drcatpc;
 547   AliMatrix(idrotm[200], 90., 0., 90., 90., 180., 0.);
 548   gMC->Gsvolu("ICCM", "PCON", idtmed[275], pcits, 9);
 549   gMC->Gspos("ICCM", 1, "ALIC", 0., 0., 0., 0, "ONLY");
 550   gMC->Gspos("ICCM", 2, "ALIC", 0., 0., 0., idrotm[200], "ONLY");
 551   gMC->Gsdvn("ITMD", "ICCM", nsec, 2);
 552   gMC->Gsatt("ITMD", "SEEN", 0);
 553   gMC->Gsatt("ICCM", "SEEN", 0);
 554
 555   //     NOW PLACE SEGMENTS WITH DECREASING PHI SEGMENTS INTO THE
 556   //     GHOST-VOLUME
 557
 558   pcits[2] = 2.;
 559   gMC->Gsvolu("ITTT", "PCON", idtmed[278], pcits, 0);
 560   r0 = rend;
 561   z0 = zend;
 562   dz = (xltpc - zend) / 9.;
 563   for(i = 0; i < 9; ++i) {
 564     zi = z0 + i*dz + dz / 2.;
 565     ri = r0 + (zi - z0) * TMath::Tan(acable * kDegrad);
 566     dphii = dphi[5] * r0 / ri;
 567     pcits[0] = -dphii / 2.;
 568     pcits[1] = dphii;
 569     pcits[3] = zi - dz / 2.;
 570     pcits[5] = r0 + (pcits[3] - z0) * TMath::Tan(acable * kDegrad);
 571     pcits[4] = pcits[5] - drcatpc;
 572     pcits[6] = zi + dz / 2.;
 573     pcits[8] = r0 + (pcits[6] - z0) * TMath::Tan(acable * kDegrad);
 574     pcits[7] = pcits[8] - drcatpc;
 575
 576     gMC->Gsposp("ITTT", i+1, "ITMD", 0., 0., 0., 0, "ONLY", pcits, 9);
 577   }
 578
 579   // --- Outputs the geometry tree in the EUCLID/CAD format
 580
 581   if (fEuclidOut) {
 582     gMC->WriteEuclid("ITSgeometry", "ITSV", 1, 5);
 583   }
 584 }
 585 //_____________________________________________________________________________
 586 void AliITSv1::CreateMaterials(){
 587 ////////////////////////////////////////////////////////////////////////
 588   //
 589   // Create ITS materials
 590   //     This function defines the default materials used in the Geant
 591   // Monte Carlo simulations for the geometries AliITSv1 and AliITSv3.
 592   // In general it is automatically replaced by
 593   // the CreatMaterials routine defined in AliITSv?. Should the function
 594   // CreateMaterials not exist for the geometry version you are using this
 595   // one is used. See the definition found in AliITSv5 or the other routine
 596   // for a complete definition.
 597   //
 598   // Water H2O
 599   Float_t awat[2]  = { 1.00794,15.9994 };
 600   Float_t zwat[2]  = { 1.,8. };
 601   Float_t wwat[2]  = { 2.,1. };
 602   Float_t denswat  = 1.;
 603   // Freon
 604   Float_t afre[2]  = { 12.011,18.9984032 };
 605   Float_t zfre[2]  = { 6.,9. };
 606   Float_t wfre[2]  = { 5.,12. };
 607   Float_t densfre  = 1.5;
 608   // Ceramics
 609   //     94.4% Al2O3 , 2.8% SiO2 , 2.3% MnO , 0.5% Cr2O3
 610   Float_t acer[5]  = { 26.981539,15.9994,28.0855,54.93805,51.9961 };
 611   Float_t zcer[5]  = { 13.,8.,14.,25.,      24. };
 612   Float_t wcer[5]  = { .49976,1.01233,.01307,       .01782,.00342 };
 613   Float_t denscer  = 3.6;
 614   //
 615   //     60% SiO2 , 40% G10FR4
 616   // PC board
 617   Float_t apcb[3]  = { 28.0855,15.9994,17.749 };
 618   Float_t zpcb[3]  = { 14.,8.,8.875 };
 619   Float_t wpcb[3]  = { .28,.32,.4 };
 620   Float_t denspcb  = 1.8;
 621   // POLYETHYL
 622   Float_t apoly[2] = { 12.01,1. };
 623   Float_t zpoly[2] = { 6.,1. };
 624   Float_t wpoly[2] = { .33,.67 };
 625   // SERVICES
 626   Float_t zserv[4] = { 1.,6.,26.,29. };
 627   Float_t aserv[4] = { 1.,12.,55.8,63.5 };
 628   Float_t wserv[4] = { .014,.086,.42,.48 };
 629
 630   Int_t  isxfld  = gAlice->Field()->Integ();
 631   Float_t sxmgmx = gAlice->Field()->Max();
 632
 633
 634   // --- Define the various materials for GEANT ---
 635
 636   //  200-224 --> Silicon Pixel Detectors (detectors, chips, buses, cooling,..)
 637
 638   AliMaterial(0, "SPD Si$",      28.0855, 14., 2.33, 9.36, 999);
 639   AliMaterial(1, "SPD Si chip$", 28.0855, 14., 2.33, 9.36, 999);
 640   AliMaterial(2, "SPD Si bus$",  28.0855, 14., 2.33, 9.36, 999);
 641   AliMaterial(3, "SPD C$",       12.011,   6., 2.265,18.8, 999);
 642   // v. dens
 643   AliMaterial(4, "SPD Air$",    14.61, 7.3, .001205, 30423., 999);
 644   AliMaterial(5, "SPD Vacuum$", 1e-16, 1e-16, 1e-16, 1e16, 1e16);
 645   AliMaterial(6, "SPD Al$",     26.981539, 13., 2.6989, 8.9, 999);
 646   AliMixture( 7, "SPD Water $", awat, zwat, denswat, -2, wwat);
 647   AliMixture( 8, "SPD Freon$",  afre, zfre, densfre, -2, wfre);
 648   // **
 649   AliMedium(0, "SPD Si$",      0, 1,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 650   AliMedium(1, "SPD Si chip$", 1, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 651   AliMedium(2, "SPD Si bus$",  2, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 652   AliMedium(3, "SPD C$",       3, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 653   AliMedium(4, "SPD Air$",     4, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 654   AliMedium(5, "SPD Vacuum$",  5, 0,isxfld,sxmgmx, 10.,1.00, .1, .100,10.00);
 655   AliMedium(6, "SPD Al$",      6, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 656   AliMedium(7, "SPD Water $",  7, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 657   AliMedium(8, "SPD Freon$",   8, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 658
 659   //  225-249 --> Silicon Drift Detectors (detectors, chips, buses, cooling,..)
 660
 661   AliMaterial(25, "SDD Si$",      28.0855, 14., 2.33,  9.36, 999);
 662   AliMaterial(26, "SDD Si chip$", 28.0855, 14., 2.33,  9.36, 999);
 663   AliMaterial(27, "SDD Si bus$",  28.0855, 14., 2.33,  9.36, 999);
 664   AliMaterial(28, "SDD C$",       12.011,   6., 2.265,18.8,  999);
 665   // v. dens
 666   AliMaterial(29, "SDD Air$",     14.61, 7.3, .001205, 30423., 999);
 667   AliMaterial(30, "SDD Vacuum$",  1e-16, 1e-16, 1e-16, 1e16,  1e16);
 668   AliMaterial(31, "SDD Al$",      26.981539, 13., 2.6989, 8.9, 999);
 669   // After a call with ratios by number (negative number of elements),
 670   // the ratio array is changed to the ratio by weight, so all successive
 671   // calls with the same array must specify the number of elements as
 672   // positive
 673   AliMixture(32, "SDD Water $", awat, zwat, denswat, 2, wwat);
 674   // After a call with ratios by number (negative number of elements),
 675   // the ratio array is changed to the ratio by weight, so all successive
 676   // calls with the same array must specify the number of elements as
 677   // positive
 678   AliMixture( 33, "SDD Freon$", afre, zfre, densfre, 2, wfre);
 679   AliMixture( 34, "SDD PCB$",   apcb, zpcb, denspcb, 3, wpcb);
 680   AliMaterial(35, "SDD Copper$", 63.546, 29., 8.96, 1.43, 999);
 681   AliMixture( 36, "SDD Ceramics$", acer, zcer, denscer, -5, wcer);
 682   AliMaterial(37, "SDD Kapton$", 12.011, 6., 1.3, 31.27, 999);
 683   // **
 684   // check A and Z
 685   AliMedium(25, "SDD Si$",      25, 1,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 686   AliMedium(26, "SDD Si chip$", 26, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 687   AliMedium(27, "SDD Si bus$",  27, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 688   AliMedium(28, "SDD C$",       28, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 689   AliMedium(29, "SDD Air$",     29, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 690   AliMedium(30, "SDD Vacuum$",  30, 0,isxfld,sxmgmx, 10.,1.00, .1, .100,10.00);
 691   AliMedium(31, "SDD Al$",      31, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 692   AliMedium(32, "SDD Water $",  32, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 693   AliMedium(33, "SDD Freon$",   33, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 694   AliMedium(34, "SDD PCB$",     34, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 695   AliMedium(35, "SDD Copper$",  35, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 696   AliMedium(36, "SDD Ceramics$",36, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 697   AliMedium(37, "SDD Kapton$",  37, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 698
 699   //  250-274 --> Silicon Strip Detectors (detectors, chips, buses, cooling,..)
 700
 701   AliMaterial(50, "SSD Si$",      28.0855, 14., 2.33, 9.36, 999.);
 702   AliMaterial(51, "SSD Si chip$", 28.0855, 14., 2.33, 9.36, 999.);
 703   AliMaterial(52, "SSD Si bus$",  28.0855, 14., 2.33, 9.36, 999.);
 704   AliMaterial(53, "SSD C$",       12.011,   6., 2.265,18.8, 999.);
 705   // v. dens
 706   AliMaterial(54, "SSD Air$",     14.61, 7.3, .001205, 30423., 999);
 707   AliMaterial(55, "SSD Vacuum$",  1e-16, 1e-16, 1e-16, 1e16, 1e16);
 708   AliMaterial(56, "SSD Al$",      26.981539, 13., 2.6989, 8.9, 999);
 709   // After a call with ratios by number (negative number of elements),
 710   // the ratio array is changed to the ratio by weight, so all successive
 711   // calls with the same array must specify the number of elements as
 712   // positive
 713   AliMixture(57, "SSD Water $", awat, zwat, denswat, 2, wwat);
 714   // After a call with ratios by number (negative number of elements),
 715   // the ratio array is changed to the ratio by weight, so all successive
 716   // calls with the same array must specify the number of elements as
 717   // positive
 718   AliMixture(58, "SSD Freon$", afre, zfre, densfre, 2, wfre);
 719   AliMixture(59, "SSD PCB$",   apcb, zpcb, denspcb, 3, wpcb);
 720   AliMaterial(60, "SSD Copper$", 63.546, 29., 8.96, 1.43, 999.);
 721   // After a call with ratios by number (negative number of elements),
 722   // the ratio array is changed to the ratio by weight, so all successive
 723   // calls with the same array must specify the number of elements as
 724   // positive
 725   AliMixture( 61, "SSD Ceramics$", acer, zcer, denscer, 5, wcer);
 726   AliMaterial(62, "SSD Kapton$", 12.011, 6., 1.3, 31.27, 999.);
 727   // check A and Z
 728   AliMaterial(63, "SDD G10FR4$", 17.749, 8.875, 1.8, 21.822, 999.);
 729   // **
 730   AliMedium(50, "SSD Si$",      50, 1,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 731   AliMedium(51, "SSD Si chip$", 51, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 732   AliMedium(52, "SSD Si bus$",  52, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 733   AliMedium(53, "SSD C$",       53, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 734   AliMedium(54, "SSD Air$",     54, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 735   AliMedium(55, "SSD Vacuum$",  55, 0,isxfld,sxmgmx, 10.,1.00, .1, .100,10.00);
 736   AliMedium(56, "SSD Al$",      56, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 737   AliMedium(57, "SSD Water $",  57, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 738   AliMedium(58, "SSD Freon$",   58, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 739   AliMedium(59, "SSD PCB$",     59, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 740   AliMedium(60, "SSD Copper$",  60, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 741   AliMedium(61, "SSD Ceramics$",61, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 742   AliMedium(62, "SSD Kapton$",  62, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 743   AliMedium(63, "SSD G10FR4$",  63, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 744
 745   //     275-299 --> General (end-caps, frames, cooling, cables, etc.)
 746
 747   AliMaterial(75, "GEN C$", 12.011, 6., 2.265, 18.8, 999.);
 748   // verify density
 749   AliMaterial(76, "GEN Air$", 14.61, 7.3, .001205, 30423., 999);
 750   AliMaterial(77, "GEN Vacuum$", 1e-16, 1e-16, 1e-16, 1e16, 1e16);
 751   AliMixture( 78, "GEN POLYETHYL$", apoly, zpoly, .95, -2, wpoly);
 752   AliMixture( 79, "GEN SERVICES$",  aserv, zserv, 4.68, 4, wserv);
 753   AliMaterial(80, "GEN Copper$", 63.546, 29., 8.96, 1.43, 999.);
 754   // After a call with ratios by number (negative number of elements),
 755   // the ratio array is changed to the ratio by weight, so all successive
 756   // calls with the same array must specify the number of elements as
 757   // positive
 758   AliMixture(81, "GEN Water $", awat, zwat, denswat, 2, wwat);
 759   // **
 760   AliMedium(75,"GEN C$",        75, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 761   AliMedium(76,"GEN Air$",      76, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 762   AliMedium(77,"GEN Vacuum$",   77, 0,isxfld,sxmgmx, 10., .10, .1, .100,10.00);
 763   AliMedium(78,"GEN POLYETHYL$",78, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 764   AliMedium(79,"GEN SERVICES$", 79, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 765   AliMedium(80,"GEN Copper$",   80, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 766   AliMedium(81,"GEN Water $",   81, 0,isxfld,sxmgmx, 10., .01, .1, .003, .003);
 767 }
 768 //_____________________________________________________________________________
 769 void AliITSv1::Init(){
 770 ////////////////////////////////////////////////////////////////////////
 771 //     Initialise the ITS after it has been created.
 772 ////////////////////////////////////////////////////////////////////////
 773     Int_t i,j,l;
 774
 775     fIdN       = fId1N;;
 776     fIdName    = new char*[fIdN];
 777     fIdSens    = new Int_t[fIdN];
 778     for(i=0;i<fId1N;i++) {
 779         l = strlen(fId1Name[i]);
 780         fIdName[i] = new char[l+1];
 781         for(j=0;j<l;j++) fIdName[i][j] = fId1Name[i][j];
 782         fIdName[i][l] = '\0'; // Null terminate this string.
 783     } // end for i
 784     //
 785     AliITS::Init();
 786     fMajorVersion = 1;
 787     fMinorVersion = 0;
 788 }
 789
 790 //_____________________________________________________________________________
 791 void AliITSv1::DrawModule(){
 792 ////////////////////////////////////////////////////////////////////////
 793 //     Draw a shaded view of the FMD version 1.
 794 ////////////////////////////////////////////////////////////////////////
 795
 796   // Set everything unseen
 797   gMC->Gsatt("*", "seen", -1);
 798   //
 799   // Set ALIC mother visible
 800   gMC->Gsatt("ALIC","SEEN",0);
 801   //
 802   // Set the volumes visible
 803   gMC->Gsatt("ITSV","SEEN",0);
 804   gMC->Gsatt("ITS1","SEEN",1);
 805   gMC->Gsatt("ITS2","SEEN",1);
 806   gMC->Gsatt("ITS3","SEEN",1);
 807   gMC->Gsatt("ITS4","SEEN",1);
 808   gMC->Gsatt("ITS5","SEEN",1);
 809   gMC->Gsatt("ITS6","SEEN",1);
 810
 811   gMC->Gsatt("IPCB","SEEN",1);
 812   gMC->Gsatt("ICO2","SEEN",1);
 813   gMC->Gsatt("ICER","SEEN",0);
 814   gMC->Gsatt("ISI2","SEEN",0);
 815   gMC->Gsatt("IPLA","SEEN",0);
 816   gMC->Gsatt("ICO3","SEEN",0);
 817   gMC->Gsatt("IEPX","SEEN",0);
 818   gMC->Gsatt("ISI3","SEEN",1);
 819   gMC->Gsatt("ISUP","SEEN",0);
 820   gMC->Gsatt("ICHO","SEEN",0);
 821   gMC->Gsatt("ICMO","SEEN",0);
 822   gMC->Gsatt("ICMD","SEEN",0);
 823   gMC->Gsatt("ICCO","SEEN",1);
 824   gMC->Gsatt("ICCM","SEEN",0);
 825   gMC->Gsatt("ITMD","SEEN",0);
 826   gMC->Gsatt("ITTT","SEEN",1);
 827
 828   //
 829   gMC->Gdopt("hide", "on");
 830   gMC->Gdopt("shad", "on");
 831   gMC->Gsatt("*", "fill", 7);
 832   gMC->SetClipBox(".");
 833   gMC->SetClipBox("*", 0, 300, -300, 300, -300, 300);
 834   gMC->DefaultRange();
 835   gMC->Gdraw("alic", 40, 30, 0, 11, 10, .07, .07);
 836   gMC->Gdhead(1111, "Inner Tracking System Version 1");
 837   gMC->Gdman(17, 6, "MAN");
 838 }
 839 //_____________________________________________________________________________
 840 void AliITSv1::StepManager(){
 841 ////////////////////////////////////////////////////////////////////////
 842 //    Called for every step in the ITS, then calles the AliITShit class
 843 // creator with the information to be recoreded about that hit.
 844 ////////////////////////////////////////////////////////////////////////
 845   /*
 846   We no longer generate hits from the cource version.
 847   Int_t         copy, id;
 848   Float_t       hits[8];
 849   Int_t         vol[4];
 850   TLorentzVector position, momentum;
 851   TClonesArray &lhits = *fHits;
 852   //
 853   // Track status
 854   vol[3] = 0;
 855   if(gMC->IsTrackInside())      vol[3] +=  1;
 856   if(gMC->IsTrackEntering())    vol[3] +=  2;
 857   if(gMC->IsTrackExiting())     vol[3] +=  4;
 858   if(gMC->IsTrackOut())         vol[3] +=  8;
 859   if(gMC->IsTrackDisappeared()) vol[3] += 16;
 860   if(gMC->IsTrackStop())        vol[3] += 32;
 861   if(gMC->IsTrackAlive())       vol[3] += 64;
 862   //
 863   // Fill hit structure.
 864   if( !(gMC->TrackCharge()) ) return;
 865     //
 866     // Only entering charged tracks
 867     if((id=gMC->CurrentVolID(copy))==fIdSens[0]) {
 868       vol[0]=1;
 869       id=gMC->CurrentVolOffID(1,copy);
 870       vol[1]=copy;
 871       id=gMC->CurrentVolOffID(2,copy);
 872       vol[2]=copy;
 873     } else if(id==fIdSens[1]) {
 874       vol[0]=2;
 875       id=gMC->CurrentVolOffID(1,copy);
 876       vol[1]=copy;
 877       id=gMC->CurrentVolOffID(2,copy);
 878       vol[2]=copy;
 879     } else if(id==fIdSens[2]) {
 880       vol[0]=3;
 881       vol[1]=copy;
 882       id=gMC->CurrentVolOffID(1,copy);
 883       vol[2]=copy;
 884     } else if(id==fIdSens[3]) {
 885       vol[0]=4;
 886       vol[1]=copy;
 887       id=gMC->CurrentVolOffID(1,copy);
 888       vol[2]=copy;
 889     } else if(id==fIdSens[4]) {
 890       vol[0]=5;
 891       vol[1]=copy;
 892       id=gMC->CurrentVolOffID(1,copy);
 893       vol[2]=copy;
 894     } else if(id==fIdSens[5]) {
 895       vol[0]=6;
 896       vol[1]=copy;
 897       id=gMC->CurrentVolOffID(1,copy);
 898       vol[2]=copy;
 899     } else return;
 900     gMC->TrackPosition(position);
 901     gMC->TrackMomentum(momentum);
 902     hits[0]=position[0];
 903     hits[1]=position[1];
 904     hits[2]=position[2];
 905     hits[3]=momentum[0];
 906     hits[4]=momentum[1];
 907     hits[5]=momentum[2];
 908     hits[6]=gMC->Edep();
 909     hits[7]=gMC->TrackTime();
 910     new(lhits[fNhits++]) AliITShit(fIshunt,gAlice->CurrentTrack(),vol,hits);
 911     we no longer generate hit from the cource version.
 912   */
 913   return;
 914 }
 915 //____________________________________________________________________________
 916 void AliITSv1::Streamer(TBuffer &R__b){
 917 ////////////////////////////////////////////////////////////////////////
 918 //    A dummy Streamer function for this class AliITSv1. By default it
 919 // only streams the AliITS class as it is required. Since this class
 920 // dosen't contain any "real" data to be saved, it doesn't.
 921 ////////////////////////////////////////////////////////////////////////
 922
 923     printf("AliITSv1Streamer Starting\n");
 924    if (R__b.IsReading()) {
 925       Version_t R__v = R__b.ReadVersion(); if (R__v) { }
 926       AliITS::Streamer(R__b);
 927       // This information does not need to be read. It is "hard wired"
 928       // into this class via its creators.
 929       //R__b >> fId1N;
 930       //R__b.ReadArray(fId1Name);
 931    } else {
 932       R__b.WriteVersion(AliITSv1::IsA());
 933       AliITS::Streamer(R__b);
 934       // This information does not need to be saved. It is "hard wired"
 935       // into this class via its creators.
 936       //R__b << fId1N;
 937       //R__b.WriteArray(fId1Name, __COUNTER__);
 938    } // end if R__b.IsReading()
 939     printf("AliITSv1Streamer Finishing\n");
 940 }