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