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