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 /* $Id$ */
  17
  18 #include <TArrayI.h>
  19
  20 #include <stdlib.h>
  21
  22 #include "AliRun.h"
  23 #include "AliITS.h"
  24 #include "AliITShit.h"
  25 #include "AliITSmodule.h"
  26 #include "AliITSgeom.h"
  27
  28 ClassImp(AliITSmodule)
  29
  30 //_______________________________________________________________________
  31 //
  32 // Impementation of class AliITSmodule
  33 //
  34 // created by: A. Bouchm, W. Peryt, S. Radomski, P. Skowronski
  35 //             R. Barbers, B. Batyunia, B. S. Nilsen
  36 // ver 1.0     CERN 16.09.1999
  37 //_______________________________________________________________________
  38 //________________________________________________________________________
  39 //
  40 // Constructors and deconstructor
  41 //________________________________________________________________________
  42 //
  43 AliITSmodule::AliITSmodule() {
  44     // constructor
  45
  46     fHitsM       = 0;
  47     fTrackIndex  = 0;
  48     fHitIndex    = 0;
  49     fITS         = 0;
  50
  51 }
  52 //_________________________________________________________________________
  53 AliITSmodule::AliITSmodule(Int_t index) {
  54   // constructor
  55
  56     fIndex      = index;
  57     fHitsM      = new TObjArray();
  58     fTrackIndex = new TArrayI(16);
  59     fHitIndex   = new TArrayI(16);
  60     fITS        = (AliITS*)(gAlice->GetDetector("ITS"));
  61 }
  62 //__________________________________________________________________________
  63 AliITSmodule::~AliITSmodule() {
  64     // The destructor for AliITSmodule. Before destoring AliITSmodule
  65     // we must first destroy all of it's members.
  66
  67     if(fHitsM){
  68       fHitsM->Delete();
  69       delete fHitsM;
  70       fHitsM = 0;
  71     } // end if
  72     delete fTrackIndex;
  73     delete fHitIndex;
  74     fITS = 0; // We don't delete this pointer since it is just a copy.
  75 }
  76 //____________________________________________________________________________
  77 AliITSmodule::AliITSmodule(const AliITSmodule &source){
  78 ////////////////////////////////////////////////////////////////////////
  79 //     Copy Constructor
  80 ////////////////////////////////////////////////////////////////////////
  81   Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
  82   exit(1);
  83 }
  84 //_____________________________________________________________________________
  85 AliITSmodule& AliITSmodule::operator=(const AliITSmodule &source){
  86 ////////////////////////////////////////////////////////////////////////
  87 //    Assignment operator
  88 ////////////////////////////////////////////////////////////////////////
  89   Error("AliITSmodule","AliITSmodule class has not to be copied! Exit.");
  90   exit(1);
  91   return *this; // fake return neded on Sun
  92 }
  93 //_________________________________________________________________________
  94 //
  95 // Hits management
  96 //__________________________________________________________________________
  97 Int_t AliITSmodule::AddHit(AliITShit* hit,Int_t t,Int_t h) {
  98 // Hits management
  99
 100   //printf("AddHit: beginning hit %p t h %d %d\n",hit,t,h);
 101     fHitsM->AddLast(new AliITShit(*hit));
 102     Int_t fNhitsM = fHitsM->GetEntriesFast();
 103     if(fNhitsM-1>=fTrackIndex->GetSize()){ // need to expand the TArrayI
 104       fTrackIndex->Set(fNhitsM+64);
 105     } // end if
 106     if(fNhitsM-1>=fHitIndex->GetSize()){ // need to expand the TArrayI
 107       fHitIndex->Set(fNhitsM+64);
 108     } // end if
 109     (*fTrackIndex)[fNhitsM-1] = t;
 110     (*fHitIndex)[fNhitsM-1]   = h;
 111     return fNhitsM;
 112 }
 113 //___________________________________________________________________________
 114 Double_t AliITSmodule::PathLength(Int_t index,AliITShit *itsHit1,
 115                                   AliITShit *itsHit2){
 116   // path lenght
 117    Float_t  x1g,y1g,z1g;
 118    Float_t  x2g,y2g,z2g;
 119    Double_t s;
 120
 121    itsHit1->GetPositionG(x1g,y1g,z1g);
 122    itsHit2->GetPositionG(x2g,y2g,z2g);
 123
 124    s = TMath::Sqrt( ((Double_t)(x2g-x1g)*(Double_t)(x2g-x1g)) +
 125                     ((Double_t)(y2g-y1g)*(Double_t)(y2g-y1g)) +
 126                     ((Double_t)(z2g-z1g)*(Double_t)(z2g-z1g))  );
 127    return s;
 128 }
 129 //___________________________________________________________________________
 130 void AliITSmodule::PathLength(Int_t index,
 131                               Float_t x,Float_t y,Float_t z,
 132                               Int_t status,Int_t &nseg,
 133                               Float_t &x1,Float_t &y1,Float_t &z1,
 134                               Float_t &dx1,Float_t &dy1,Float_t &dz1,
 135                               Int_t &flag){
 136   // path length
 137     static Float_t x0,y0,z0;
 138
 139     if ((status&0x0002)!=0){ // entering
 140         x0 = x;
 141         y0 = y;
 142         z0 = z;
 143         nseg = 0;
 144         flag = 1;
 145     }else{
 146         x1 = x0;
 147         y1 = y0;
 148         z1 = z0;
 149         dx1 = x-x1;
 150         dy1 = y-y1;
 151         dz1 = z-z1;
 152         nseg++;
 153         if ((status&0x0004)!=0) flag = 0; //exiting
 154         if ((status&0x0001)!=0) flag = 2; // inside
 155         else flag = 2; //inside ?
 156         x0 = x;
 157         y0 = y;
 158         z0 = z;
 159     } // end if
 160 }
 161 //___________________________________________________________________________
 162 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
 163                                   Double_t &c,Double_t &d,
 164                                   Double_t &e,Double_t &f,Double_t &de){
 165   // line segment
 166     AliITShit *h1;
 167     Double_t t;
 168
 169     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 170
 171     h1 = (AliITShit *) (fHitsM->At(hitindex));
 172     if(h1->StatusEntering()){ // if track entering volume, get index for next
 173                               // step
 174         return kFALSE;
 175     } // end if StatusEntering()
 176     // else stepping
 177     de = h1->GetIonization();
 178     h1->GetPositionL0(a,c,e,t);
 179     h1->GetPositionL(b,d,f);
 180     b = b - a;
 181     d = d - c;
 182     f = f - e;
 183     return kTRUE;
 184 }
 185 //___________________________________________________________________________
 186 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
 187                                   Double_t &c,Double_t &d,
 188                                   Double_t &e,Double_t &f,Double_t &de){
 189   // line segment
 190     AliITShit *h1;
 191     Double_t t;
 192
 193     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 194
 195     h1 = (AliITShit *) (fHitsM->At(hitindex));
 196     if(h1->StatusEntering()){ // if track entering volume, get index for next
 197                               // step
 198         return kFALSE;
 199     } // end if StatusEntering()
 200     // else stepping
 201     de = h1->GetIonization();
 202     h1->GetPositionG0(a,c,e,t);
 203     h1->GetPositionG(b,d,f);
 204     b = b - a;
 205     d = d - c;
 206     f = f - e;
 207     return kTRUE;
 208 }
 209 //___________________________________________________________________________
 210 Bool_t AliITSmodule::LineSegmentL(Int_t hitindex,Double_t &a,Double_t &b,
 211                                   Double_t &c,Double_t &d,
 212                                   Double_t &e,Double_t &f,
 213                                   Double_t &de,Int_t &track){
 214   // line segmente
 215     AliITShit *h1;
 216     Double_t t;
 217
 218     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 219
 220     h1 = (AliITShit *) (fHitsM->At(hitindex));
 221     if(h1->StatusEntering()){ // if track entering volume, get index for next
 222                               // step
 223         track = h1->GetTrack();
 224         return kFALSE;
 225     } // end if StatusEntering()
 226     // else stepping
 227     de = h1->GetIonization();
 228     h1->GetPositionL0(a,c,e,t);
 229     h1->GetPositionL(b,d,f);
 230     b = b - a;
 231     d = d - c;
 232     f = f - e;
 233     track = h1->GetTrack();
 234     return kTRUE;
 235 }
 236 //___________________________________________________________________________
 237 Bool_t AliITSmodule::LineSegmentG(Int_t hitindex,Double_t &a,Double_t &b,
 238                                   Double_t &c,Double_t &d,
 239                                   Double_t &e,Double_t &f,
 240                                   Double_t &de,Int_t &track){
 241   // line segment
 242     AliITShit *h1;
 243     Double_t t;
 244
 245     if(hitindex>= fHitsM->GetEntriesFast()) return kFALSE;
 246
 247     h1 = (AliITShit *) (fHitsM->At(hitindex));
 248     if(h1->StatusEntering()){ // if track entering volume, get index for next
 249                               // step
 250         track = h1->GetTrack();
 251         return kFALSE;
 252     } // end if StatusEntering()
 253     // else stepping
 254     de = h1->GetIonization();
 255     h1->GetPositionG0(a,c,e,t);
 256     h1->GetPositionG(b,d,f);
 257     b = b - a;
 258     d = d - c;
 259     f = f - e;
 260     track = h1->GetTrack();
 261     return kTRUE;
 262 }
 263 //______________________________________________________________________
 264 Bool_t AliITSmodule::MedianHitG(AliITShit *h1,AliITShit *h2,
 265                                 Float_t &x,Float_t &y,Float_t &z){
 266     // Computes the mean hit location for a set of hits that make up a track
 267     // passing through a volume. Returns kFALSE untill the the track leaves
 268     // the volume.
 269     // median hit
 270    AliITSgeom *gm = fITS->GetITSgeom();
 271    Float_t x1l=0.,y1l=0.,z1l=0.;
 272    Float_t x2l=0.,y2l=0.,z2l=0.;
 273    Float_t xMl,yMl=0,zMl;
 274    Float_t l[3], g[3];
 275
 276    h1->GetPositionG(x1l,y1l,z1l);
 277    h2->GetPositionG(x2l,y2l,z2l);
 278
 279    if((y2l*y1l)<0.) {
 280      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 281      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 282    } else {
 283      xMl = 0.5*(x1l+x2l);
 284      zMl = 0.5*(z1l+z2l);
 285    }
 286
 287    l[0] = xMl;
 288    l[1] = yMl;
 289    l[2] = zMl;
 290    gm->LtoG(h1->GetModule(),l,g);
 291    x = g[0];
 292    y = g[1];
 293    z = g[2];
 294    return kTRUE;
 295 }
 296 //___________________________________________________________________________
 297 void AliITSmodule::MedianHitG(Int_t index,
 298                               Float_t hitx1,Float_t hity1,Float_t hitz1,
 299                               Float_t hitx2,Float_t hity2,Float_t hitz2,
 300                               Float_t &xMg, Float_t &yMg, Float_t &zMg){
 301   // median hit
 302    AliITSgeom *gm = fITS->GetITSgeom();
 303    Float_t x1l,y1l,z1l;
 304    Float_t x2l,y2l,z2l;
 305    Float_t xMl,yMl=0,zMl;
 306    Float_t l[3], g[3];
 307
 308    g[0] = hitx1;
 309    g[1] = hity1;
 310    g[2] = hitz1;
 311    gm->GtoL(index,g,l);
 312    x1l = l[0];
 313    y1l = l[1];
 314    z1l = l[2];
 315
 316    g[0] = hitx2;
 317    g[1] = hity2;
 318    g[2] = hitz2;
 319    gm->GtoL(index,g,l);
 320    x2l = l[0];
 321    y2l = l[1];
 322    z2l = l[2];
 323
 324    if((y2l*y1l)<0.) {
 325      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 326      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 327    } else {
 328      xMl = 0.5*(x1l+x2l);
 329      zMl = 0.5*(z1l+z2l);
 330    }
 331
 332    l[0] = xMl;
 333    l[1] = yMl;
 334    l[2] = zMl;
 335    gm->LtoG(index,l,g);
 336    xMg = g[0];
 337    yMg = g[1];
 338    zMg = g[2];
 339 }
 340 //___________________________________________________________________________
 341 Bool_t AliITSmodule::MedianHitL( AliITShit *itsHit1,
 342                              AliITShit *itsHit2,
 343                              Float_t &xMl, Float_t &yMl, Float_t &zMl){
 344   // median hit
 345    Float_t x1l,y1l,z1l;
 346    Float_t x2l,y2l,z2l;
 347
 348    itsHit1->GetPositionL(x1l,y1l,z1l);
 349    itsHit2->GetPositionL(x2l,y2l,z2l);
 350
 351    yMl = 0.0;
 352    if((y2l*y1l)<0.) {
 353      xMl = (-y1l / (y2l-y1l))*(x2l-x1l) + x1l;
 354      zMl = (-y1l / (y2l-y1l))*(z2l-z1l) + z1l;
 355    } else {
 356      xMl = 0.5*(x1l+x2l);
 357      zMl = 0.5*(z1l+z2l);
 358    }
 359    return kTRUE;
 360 }
 361 //___________________________________________________________________________
 362 void AliITSmodule::MedianHit(Int_t index,
 363                              Float_t xg,Float_t yg,Float_t zg,
 364                              Int_t status,
 365                              Float_t &xMg,Float_t &yMg,Float_t &zMg,
 366                              Int_t &flag){
 367   // median hit
 368    static Float_t x1,y1,z1;
 369
 370    if ((status&0x0002)!=0){ // entering
 371        x1 = xg;
 372        y1 = yg;
 373        z1 = zg;
 374        flag = 1;
 375    } else if ((status&0x0004)!=0){ // exiting
 376        MedianHitG(index,x1,y1,z1,xg,yg,zg,xMg,yMg,zMg);
 377        flag = 0;
 378    } // end if
 379    else  flag = 1;
 380 }
 381 //___________________________________________________________________________
 382 void AliITSmodule::GetID(Int_t &lay,Int_t &lad,Int_t &det){
 383   // get ID
 384         fITS->GetITSgeom()->GetModuleId(fIndex,lay,lad,det);
 385         return ;
 386 }
 387