ITS/AliITSmodule.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.10.4.2  2002/07/24 09:27:50  alibrary
  19 Updating on VirtualMC
  20
  21 Revision 1.13  2002/06/12 18:59:47  nilsen
  22 Added Starting track location to hit class and related changes to modules.
  23 This is at present still fully backwards compatible since starting hits
  24 are still written to the file. When aliroot v4.0 will be released, this
  25 backwards compatiblity will be broken by removing the enterence hit, and making
  26 the nessesary changes to module at that time.
  27
  28 Revision 1.12  2002/06/10 17:31:03  nilsen
  29 Replaced TArrayI expansion with Root version.
  30
  31 Revision 1.11  2002/06/04 18:43:15  nilsen
  32 Fix to avoid divide by zero problem in MedianHitG and MedianHitL for track
  33 that enter and exit the same side of a detector sensitive volume. Needed
  34 for Fast simulation. Thanks to Nicola Carrer.
  35
  36 Revision 1.10  2002/03/15 17:21:54  nilsen
  37 Removed zero-ing of fModules variable in constructors.
  38
  39 Revision 1.9  2000/10/04 19:46:39  barbera
  40 Corrected by F. Carminati for v3.04
  41
  42 Revision 1.8  2000/10/02 16:32:57  barbera
  43 Forward declarations added and formatting
  44
  45 Revision 1.3.4.8  2000/10/02 15:55:26  barbera
  46 Forward declarations added and formatting
  47
  48 Revision 1.7  2000/09/22 12:36:38  nilsen
  49 Minor changes to improve compilation and create less NOISE.
  50
  51 Revision 1.6  2000/07/10 16:07:18  fca
  52 Release version of ITS code
  53
  54 Revision 1.3.4.2  2000/03/02 21:42:29  nilsen
  55 Linked AliDetector::fDigit to AliITSmodule::fDigitsM and AliITS::fITSRecPoints
  56 to AliITSmodule::fRecPointsM. Renamed AliITSmodule::fPointsM to fRecPointsM.
  57 Removed the deletion of fDigitsM from the distructor since it is only a copy
  58 of what is in AliDetector. Fixed a bug in the functions LineSegmentL and
  59 LineSegmentG. Added two new versions of LineSegmentL and LineSegmentG to
  60 additionaly return track number from the hit. Removed FastPoint function,
  61 haven't found anywere it was used, also it had very many problems, should
  62 just call FastPointSPD... .
  63
  64 Revision 1.3.4.1  2000/01/12 19:03:32  nilsen
  65 This is the version of the files after the merging done in December 1999.
  66 See the ReadMe110100.txt file for details
  67
  68 Revision 1.3  1999/10/04 15:20:12  fca
  69 Correct syntax accepted by g++ but not standard for static members, remove minor warnings
  70
  71 Revision 1.2  1999/09/29 09:24:20  fca
  72 Introduction of the Copyright and cvs Log
  73
  74 */
  75
  76 #include <TArrayI.h>
  77
  78 #include <stdlib.h>
  79
  80 #include "AliRun.h"
  81 #include "AliITS.h"
  82 #include "AliITShit.h"
  83 #include "AliITSmodule.h"
  84 #include "AliITSgeom.h"
  85
  86 ClassImp(AliITSmodule)
  87
  88 //_______________________________________________________________________
  89 //
  90 // Impementation of class AliITSmodule
  91 //
  92 // created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski
  93 //             R. Barbers, B. Batyunia, B. S. Nilsen
  94 // ver 1.0     CERN 16.09.1999
  95 //_______________________________________________________________________
  96 //________________________________________________________________________
  97 //
  98 // Constructors and deconstructor
  99 //________________________________________________________________________
 100 //
 101 AliITSmodule::AliITSmodule() {
 102     // constructor
 103
 104     fHitsM       = 0;
 105     fTrackIndex  = 0;
 106     fHitIndex    = 0;
 107     fITS         = 0;
 108
 109 }
 110 //_________________________________________________________________________
 111 AliITSmodule::AliITSmodule(Int_t index) {
 112   // constructor
 113
 114     fIndex      = index;
 115     fHitsM      = new TObjArray();
 116     fTrackIndex = new TArrayI(16);
 117     fHitIndex   = new TArrayI(16);
 118     fITS        = (AliITS*)(gAlice->GetDetector("ITS"));
 119 }
 120 //__________________________________________________________________________
 121 AliITSmodule::~AliITSmodule() {
 122     // The destructor for AliITSmodule. Before destoring AliITSmodule
 123     // we must first destroy all of it's members.
 124
 125     if(fHitsM){
 126         for(Int_t i=0;i<fHitsM->GetEntriesFast();i++)
 127             delete ((AliITShit *)(fHitsM->At(i)));
 128         // must delete each object in the TObjArray.
 129         delete fHitsM;
 130     } // end if
 131     delete fTrackIndex;
 132     delete fHitIndex;
 133     fITS = 0; // We don't delete this pointer since it is just a copy.
 134 }
 135 //____________________________________________________________________________
 136 AliITSmodule::AliITSmodule(const AliITSmodule &source){
 137 ////////////////////////////////////////////////////////////////////////
 138 //     Copy Constructor
 139 ////////////////////////////////////////////////////////////////////////
 140   printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
 141   exit(1);
 142 }
 143
 144 //_____________________________________________________________________________
 145 AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
 146 ////////////////////////////////////////////////////////////////////////
 147 //    Assignment operator
 148 ////////////////////////////////////////////////////////////////////////
 149   printf("AliITSmodule error: AliITSmodule class has not to be copied! Exit.\n");
 150   exit(1);
 151   return *this; // fake return neded on Sun
 152 }
 153
 154 //_________________________________________________________________________
 155 //
 156 // Hits management
 157 //__________________________________________________________________________
 158 Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
 159 // Hits management
 160
 161   //printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
 162     fHitsM->AddLast(new AliITShit(*hit));
 163     Int_t fNhitsM = fHitsM->GetEntriesFast();
 164     if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
 165       fTrackIndex->Set(fNhitsM+64);
 166     } // end if
 167     if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
 168       fHitIndex->Set(fNhitsM+64);
 169     } // end if
 170     (*fTrackIndex)[fNhitsM-1] = t;
 171     (*fHitIndex)[fNhitsM-1]   = h;
 172     return fNhitsM;
 173 }
 174 //___________________________________________________________________________
 175 Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
 176                                   AliITShit *itsHit2){
 177   // path lenght
 178    Float_t  x1g,y1g,z1g;
 179    Float_t  x2g,y2g,z2g;
 180    Double_t s;
 181
 182    itsHit1->GetPositionG(x1g,y1g,z1g);
 183    itsHit2->GetPositionG(x2g,y2g,z2g);
 184
 185    s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
 186                     ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
 187                     ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
 188    return s;
 189 }
 190 //___________________________________________________________________________
 191 void AliITSmodule::PathLength(Int_t index,
 192                               Float_t x,Float_t y,Float_t z,
 193                               Int_t status,Int_t &nseg,
 194                               Float_t &x1,Float_t &y1,Float_t &z1,
 195                               Float_t &dx1,Float_t &dy1,Float_t &dz1,
 196                               Int_t &flag){
 197   // path length
 198     static Float_t x0,y0,z0;
 199
 200     if ((status&0x0002)!=0){ // entering
 201         x0 = x;
 202         y0 = y;
 203         z0 = z;
 204         nseg = 0;
 205         flag = 1;
 206     }else{
 207         x1 = x0;
 208         y1 = y0;
 209         z1 = z0;
 210         dx1 = x-x1;
 211         dy1 = y-y1;
 212         dz1 = z-z1;
 213         nseg++;
 214         if ((status&0x0004)!=0) flag = 0; //exiting
 215         if ((status&0x0001)!=0) flag = 2; // inside
 216         else flag = 2; //inside ?
 217         x0 = x;
 218         y0 = y;
 219         z0 = z;
 220     } // end if
 221 }
 222 //___________________________________________________________________________
 223 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
 224                                   Double_t &c,Double_t &d,
 225                                   Double_t &e,Double_t &f,Double_t &de){
 226   // line segment
 227     static Int_t hitindex0;
 228     AliITShit *h0,*h1;
 229
 230     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 231
 232     h1 = (AliITShit *) (fHitsM->At(hitindex));
 233     if(h1->StatusEntering()){ // if track entering volume, get index for next
 234                               // step
 235         hitindex0 = hitindex;
 236         return kFALSE;
 237     } // end if StatusEntering()
 238     // else stepping
 239     h0 = (AliITShit *) (fHitsM->At(hitindex0));
 240     de = h1->GetIonization();
 241     h0->GetPositionL(a,c,e);
 242     h1->GetPositionL(b,d,f);
 243     b = b - a;
 244     d = d - c;
 245     f = f - e;
 246     hitindex0 = hitindex;
 247     return kTRUE;
 248 }
 249 //___________________________________________________________________________
 250 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
 251                                   Double_t &c,Double_t &d,
 252                                   Double_t &e,Double_t &f,Double_t &de){
 253   // line segment
 254     static Int_t hitindex0;
 255     AliITShit *h0,*h1;
 256
 257     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 258
 259     h1 = (AliITShit *) (fHitsM->At(hitindex));
 260     if(h1->StatusEntering()){ // if track entering volume, get index for next
 261                               // step
 262         hitindex0 = hitindex;
 263         return kFALSE;
 264     } // end if StatusEntering()
 265     // else stepping
 266     h0 = (AliITShit *) (fHitsM->At(hitindex0));
 267     de = h1->GetIonization();
 268     h0->GetPositionG(a,c,e);
 269     h1->GetPositionG(b,d,f);
 270     b = b - a;
 271     d = d - c;
 272     f = f - e;
 273     hitindex0 = hitindex;
 274     return kTRUE;
 275 }
 276 //___________________________________________________________________________
 277 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
 278                                   Double_t &c,Double_t &d,
 279                                   Double_t &e,Double_t &f,
 280                                   Double_t &de,Int_t &track){
 281   // line segmente
 282     static Int_t hitindex0;
 283     AliITShit *h0,*h1;
 284
 285     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 286
 287     h1 = (AliITShit *) (fHitsM->At(hitindex));
 288     if(h1->StatusEntering()){ // if track entering volume, get index for next
 289                               // step
 290         hitindex0 = hitindex;
 291         track = h1->GetTrack();
 292         return kFALSE;
 293     } // end if StatusEntering()
 294     // else stepping
 295     h0 = (AliITShit *) (fHitsM->At(hitindex0));
 296     de = h1->GetIonization();
 297     h0->GetPositionL(a,c,e);
 298     h1->GetPositionL(b,d,f);
 299     b = b - a;
 300     d = d - c;
 301     f = f - e;
 302     hitindex0 = hitindex;
 303     track = h1->GetTrack();
 304     return kTRUE;
 305 }
 306 //___________________________________________________________________________
 307 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
 308                                   Double_t &c,Double_t &d,
 309                                   Double_t &e,Double_t &f,
 310                                   Double_t &de,Int_t &track){
 311   // line segment
 312     static Int_t hitindex0;
 313     AliITShit *h0,*h1;
 314
 315     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 316
 317     h1 = (AliITShit *) (fHitsM->At(hitindex));
 318     if(h1->StatusEntering()){ // if track entering volume, get index for next
 319                               // step
 320         hitindex0 = hitindex;
 321         track = h1->GetTrack();
 322         return kFALSE;
 323     } // end if StatusEntering()
 324     // else stepping
 325     h0 = (AliITShit *) (fHitsM->At(hitindex0));
 326     de = h1->GetIonization();
 327     h0->GetPositionG(a,c,e);
 328     h1->GetPositionG(b,d,f);
 329     b = b - a;
 330     d = d - c;
 331     f = f - e;
 332     hitindex0 = hitindex;
 333     track = h1->GetTrack();
 334     return kTRUE;
 335 }
 336 //______________________________________________________________________
 337 Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
 338                                 Float_t &x,Float_t &y,Float_t &z){
 339     // Computes the mean hit location for a set of hits that make up a track
 340     // passing through a volume. Returns kFALSE untill the the track leaves
 341     // the volume.
 342     // median hit
 343    AliITSgeom *gm = fITS->GetITSgeom();
 344    Float_t x1l=0.,y1l=0.,z1l=0.;
 345    Float_t x2l=0.,y2l=0.,z2l=0.;
 346    Float_t xMl,yMl=0,zMl;
 347    Float_t l[3], g[3];
 348
 349    h1->GetPositionG(x1l,y1l,z1l);
 350    h2->GetPositionG(x2l,y2l,z2l);
 351
 352    // Modified by N.Carrer. In very rare occasions the track may be just
 353    // tangent to the module. Therefore the entrance and exit points have the
 354    // same y.
 355    if( (y2l-y1l) != 0.0 ) {
 356      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 357      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 358    } else {
 359      xMl = 0.5*(x1l+x2l);
 360      zMl = 0.5*(z1l+z2l);
 361    }
 362
 363    l[0] = xMl;
 364    l[1] = yMl;
 365    l[2] = zMl;
 366    gm->LtoG(h1->GetModule(),l,g);
 367    x = g[0];
 368    y = g[1];
 369    z = g[2];
 370    return kTRUE;
 371 }
 372 //___________________________________________________________________________
 373 void AliITSmodule::MedianHitG(Int_t index,
 374                               Float_t hitx1,Float_t hity1,Float_t hitz1,
 375                               Float_t hitx2,Float_t hity2,Float_t hitz2,
 376                               Float_t &xMg, Float_t &yMg, Float_t &zMg){
 377   // median hit
 378    AliITSgeom *gm = fITS->GetITSgeom();
 379    Float_t x1l,y1l,z1l;
 380    Float_t x2l,y2l,z2l;
 381    Float_t xMl,yMl=0,zMl;
 382    Float_t l[3], g[3];
 383
 384    g[0] = hitx1;
 385    g[1] = hity1;
 386    g[2] = hitz1;
 387    gm->GtoL(index,g,l);
 388    x1l = l[0];
 389    y1l = l[1];
 390    z1l = l[2];
 391
 392    g[0] = hitx2;
 393    g[1] = hity2;
 394    g[2] = hitz2;
 395    gm->GtoL(index,g,l);
 396    x2l = l[0];
 397    y2l = l[1];
 398    z2l = l[2];
 399
 400    // Modified by N.Carrer. In very rare occasions the track may be just
 401    // tangent to the module. Therefore the entrance and exit points have the
 402    // same y.
 403    if( (y2l-y1l) != 0.0 ) {
 404      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 405      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 406    } else {
 407      xMl = 0.5*(x1l+x2l);
 408      zMl = 0.5*(z1l+z2l);
 409    }
 410
 411    l[0] = xMl;
 412    l[1] = yMl;
 413    l[2] = zMl;
 414    gm->LtoG(index,l,g);
 415    xMg = g[0];
 416    yMg = g[1];
 417    zMg = g[2];
 418 }
 419 //___________________________________________________________________________
 420 Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1,
 421                              AliITShit *itsHit2,
 422                              Float_t &xMl, Float_t &yMl, Float_t &zMl){
 423   // median hit
 424    Float_t x1l,y1l,z1l;
 425    Float_t x2l,y2l,z2l;
 426
 427    itsHit1->GetPositionL(x1l,y1l,z1l);
 428    itsHit2->GetPositionL(x2l,y2l,z2l);
 429
 430    yMl = 0.0;
 431    // Modified by N.Carrer. In very rare occasions the track may be just
 432    // tangent to the module. Therefore the entrance and exit points have the
 433    // same y.
 434    if( (y2l-y1l) != 0.0 ) {
 435      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 436      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 437    } else {
 438      xMl = 0.5*(x1l+x2l);
 439      zMl = 0.5*(z1l+z2l);
 440    }
 441    return kTRUE;
 442 }
 443 //___________________________________________________________________________
 444 void AliITSmodule::MedianHit(Int_t index,
 445                              Float_t xg,Float_t yg,Float_t zg,
 446                              Int_t status,
 447                              Float_t &xMg,Float_t &yMg,Float_t &zMg,
 448                              Int_t &flag){
 449   // median hit
 450    static Float_t x1,y1,z1;
 451
 452    if ((status&0x0002)!=0){ // entering
 453        x1 = xg;
 454        y1 = yg;
 455        z1 = zg;
 456        flag = 1;
 457    } else if ((status&0x0004)!=0){ // exiting
 458        MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
 459        flag = 0;
 460    } // end if
 461    else  flag = 1;
 462 }
 463 //___________________________________________________________________________
 464 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
 465   // get ID
 466         fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
 467         return ;
 468 }
 469