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