ITS/AliITSclusterSSD.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 <Riostream.h>
  19 #include "TArrayI.h"
  20 #include "TClonesArray.h"
  21 #include "AliITSdigit.h"
  22 #include "AliITSclusterSSD.h"
  23
  24 ClassImp(AliITSclusterSSD)
  25
  26 //______________________________________________________________________
  27 AliITSclusterSSD::AliITSclusterSSD(){
  28     // default constructor
  29
  30     fSide        = kTRUE;
  31     fDigits      = 0;
  32     fNDigits     = 0;
  33     fDigitsIndex = 0;
  34     fNCrosses    = 0;
  35     fTotalSignal = -1;
  36     fNTracks      = -1;
  37     fLeftNeighbour  = kFALSE;
  38     fRightNeighbour = kFALSE;
  39     fCrossedClusterIndexes = 0;
  40     fConsumed=kFALSE;
  41 }
  42 //______________________________________________________________________
  43 AliITSclusterSSD::AliITSclusterSSD(Int_t ndigits, Int_t *DigitIndexes,
  44                                    TObjArray *Digits, Bool_t side){
  45     // non-default constructor
  46
  47     fNDigits = ndigits;
  48     fDigits = Digits;
  49     fSide = side;
  50     fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );
  51     fNCrosses    = 0;
  52     fCrossedClusterIndexes = new TArrayI(300);
  53     fLeftNeighbour  = kFALSE;
  54     fRightNeighbour = kFALSE;
  55     fTotalSignal =-1;
  56     fNTracks    = -1;
  57     fConsumed=kFALSE;
  58 }
  59 //______________________________________________________________________
  60 AliITSclusterSSD::~AliITSclusterSSD(){
  61     // destructor
  62
  63     delete fDigitsIndex;
  64     delete fCrossedClusterIndexes;
  65 }
  66 //______________________________________________________________________
  67 AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster){
  68     // copy constructor
  69
  70     if (this == &OneSCluster) return;
  71     fNDigits = OneSCluster.fNDigits;
  72     fSide=OneSCluster.fSide;
  73     fDigits=OneSCluster.fDigits;
  74     fDigitsIndex = new TArrayI(fNDigits);
  75     fLeftNeighbour  = OneSCluster.fLeftNeighbour;
  76     fRightNeighbour = OneSCluster.fRightNeighbour;
  77     fTotalSignal =-1;
  78     fNTracks     = -1;
  79     fNCrosses = OneSCluster.fNCrosses;
  80     fConsumed = OneSCluster.fConsumed;
  81     Int_t i;
  82     for (i = 0; i< fNCrosses ; i++){
  83         fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
  84     }
  85     for (i = 0; i< fNDigits ; i++){
  86         fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
  87     }
  88     return;
  89 }
  90 //______________________________________________________________________
  91 AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD
  92                                               &OneSCluster){
  93     // assignment operator
  94
  95     if (this == &OneSCluster) return *this;
  96     fNDigits = OneSCluster.fNDigits;
  97     fSide=OneSCluster.fSide;
  98     fDigits=OneSCluster.fDigits;
  99     fDigitsIndex = new TArrayI(fNDigits);
 100     fLeftNeighbour  = OneSCluster.fLeftNeighbour;
 101     fRightNeighbour = OneSCluster.fRightNeighbour;
 102     fTotalSignal =-1;
 103     fNTracks     = -1;
 104     fNCrosses = OneSCluster.fNCrosses;
 105     fConsumed = OneSCluster.fConsumed;
 106     Int_t i;
 107     for (i = 0; i< fNCrosses ; i++){
 108         fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
 109     }
 110     for (i = 0; i< fNDigits ; i++){
 111         fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
 112     }
 113     return *this;
 114 }
 115 //______________________________________________________________________
 116 Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits){
 117     //This methods generate data necessery to make new object of this class
 118     //I choosen this way, because methods TClonesArray::Add* dont work
 119     //so I have to use constraction: new (a[i]) Creator(params...);
 120     //where 'a' is a TClonesArray
 121     //This method generate params - see AliITSmoduleSSD::SplitCluster;
 122     Int_t tmp = fNDigits;
 123     Int_t ind = 0;
 124
 125     outdigits[ind++]=(*fDigitsIndex)[where];
 126     //coping border strip (it is shared by this two clusters)
 127     for (Int_t i = (where+1); i < tmp; i++) {
 128         outdigits[ind++]=(*fDigitsIndex)[i];
 129         //"moving" strips from this to the new one
 130         (*fDigitsIndex)[i]=-1;
 131         fNDigits--;   //deleting strips from this cluster
 132     }
 133     return ind;
 134 }
 135 //______________________________________________________________________
 136 Int_t AliITSclusterSSD::GetDigitStripNo(Int_t digit){
 137     // return strip no of a digit
 138     if (digit<0) return -1;
 139     return (digit>(fNDigits-1)) ? -1 :
 140         ((AliITSdigitSSD*)(fDigits->At((*fDigitsIndex)[digit])))->GetStripNumber();
 141 }
 142 //______________________________________________________________________
 143 Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit){
 144     // returns digit signal
 145     Int_t index,signal;
 146     if (digit<0||digit>=fNDigits) return -1;
 147     index  = (*fDigitsIndex)[digit];
 148     signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
 149     /*
 150       if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
 151       digit,index, signal);
 152     */
 153     return  signal;
 154 }
 155 //______________________________________________________________________
 156 void  AliITSclusterSSD::AddCross(Int_t clIndex){
 157     // add cluster cross to list of cluster crosses
 158
 159     (*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
 160 }
 161 //______________________________________________________________________
 162 Int_t AliITSclusterSSD::GetCross(Int_t crIndex){
 163     // return crossing cluster
 164
 165     return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
 166 }
 167 //______________________________________________________________________
 168 Double_t AliITSclusterSSD::CentrOfGravity(){
 169     // return center of gravity of the cluster
 170     Float_t ret=0;
 171
 172     if (fLeftNeighbour) ret+=(GetDigitStripNo(0)*0.5*GetDigitSignal(0));
 173     else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
 174     if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
 175     else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
 176     for (Int_t i=1;i<fNDigits-1;i++){
 177         ret +=GetDigitStripNo(i)*GetDigitSignal(i);
 178     }// end for i
 179
 180     if (fTotalSignal<0) GetTotalSignal();
 181
 182     return (ret/fTotalSignal);
 183 }
 184 //______________________________________________________________________
 185 Float_t AliITSclusterSSD::GetTotalSignal(){
 186     // return total signal
 187
 188     if(fTotalSignal <0){
 189         fTotalSignal=0;
 190         if (fNDigits ==1)  {
 191             fTotalSignal = (Float_t)GetDigitSignal(0);
 192             //printf("1 digit: signal %d \n",GetDigitSignal(0));
 193             return fTotalSignal;
 194         }
 195         if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
 196         else fTotalSignal += (Float_t) GetDigitSignal(0);
 197         //printf("GetTotalSignal :i DigitSignal %d %d \n",0,GetDigitSignal(0));
 198         if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(
 199                                                                  fNDigits -1));
 200       else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
 201         //printf("GetTotalSignal :i  DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1));
 202         for (Int_t i = 1;i<fNDigits -1;i++){
 203             fTotalSignal += (Float_t)GetDigitSignal(i);
 204             //printf("GetTotalSignal :i  DigitSignal %d %d \n",i,GetDigitSignal(i));
 205         }
 206         //printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal);
 207     }
 208     return fTotalSignal;
 209 }
 210 //______________________________________________________________________
 211 Float_t  AliITSclusterSSD::GetTotalSignalError(){
 212     // return the error on the signal
 213     Float_t err =0;
 214     for (Int_t i =1; i<fNDigits -1; i++){
 215         err+=0.1*GetDigitSignal(i);
 216     }
 217     if (GetLeftNeighbour()){
 218         err+=GetDigitSignal(0);
 219     }else{
 220         err+=0.1*GetDigitSignal(0);
 221     }
 222     if (GetRightNeighbour()){
 223         err+=GetDigitSignal(fNDigits -1);
 224     }else{
 225         err+=0.1*GetDigitSignal(fNDigits -1);
 226     }
 227     return err;
 228 }
 229 //______________________________________________________________________
 230 void AliITSclusterSSD::DelCross(Int_t index){
 231     // remove cross clusters from the list of cross clusters
 232     Int_t i,j; //iterators
 233
 234     for (i =0;i<fNCrosses;i++){
 235         if ((*fCrossedClusterIndexes)[i] == index){
 236             for (j=i;j<fNCrosses-1;j++){
 237                 (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
 238             }
 239             fNCrosses--;
 240             return;
 241         }
 242     }
 243 }
 244 //______________________________________________________________________
 245 Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt){
 246     // return the track number of the cluster
 247     Int_t ntrk = GetDigit(0)->GetNTracks();
 248     Int_t ndig = GetNumOfDigits();
 249     Int_t *idig = new Int_t[ndig];
 250     Int_t *sdig = new Int_t[ndig];
 251     Int_t *itrk = new Int_t[ndig*ntrk];
 252     Int_t i,j,k,l,trk;
 253     Bool_t b;
 254
 255     for(i=0;i<ndig;i++){idig[i] = i;sdig[i] = GetDigit(i)->GetSignal();}
 256     TMath::Sort(ndig,sdig,idig,kTRUE);
 257     for(i=0;i<ndig*ntrk;i++) itrk[i] = -3;
 258     j = k = l = 0;
 259     for(i=0;i<ndig;i++){ // fill itrk with track numbers in order of digit size
 260         j = idig[i];
 261         for(k=0;k<ntrk;k++) if((trk = GetDigit(j)->GetTrack(k))>=0) {
 262             itrk[l] = trk;
 263             l++;
 264         } // end for k/if
 265     } // end for i
 266     for(i=0;i<10;i++) fTrack[i] = -3;
 267     fTrack[0] = itrk[0]; // first element
 268     k = 1;
 269     b = kTRUE;
 270     for(i=1;i<l;i++){
 271         for(j=0;j<k;j++) if(fTrack[j]==itrk[i]) b = kFALSE;
 272         if(b){fTrack[k] = itrk[i]; k++;}
 273         if(k>9) break;
 274     } // end for i
 275     nt = k;
 276
 277     delete[] idig;
 278     delete[] sdig;
 279     delete[] itrk;
 280
 281     return fTrack;
 282 /*
 283     Int_t *tidx=0;
 284     Int_t i, j,n;
 285     Int_t bit =0;
 286     Int_t ntracks=0;
 287     nt=0;
 288
 289     for (i=0;i<10;i++) fTrack[i] = -3;
 290
 291     //cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;
 292
 293     for (i = 0; i<fNDigits; i++) {
 294         tidx = GetDigit(i)->GetTracks();
 295         n    = GetDigit(i)->GetNTracks();
 296         for (j = 0; j<n && j<10;j++) {
 297             if (tidx[j] >= 0) {
 298                 if(ntracks == 0){
 299                     fTrack[ntracks] = tidx[j];
 300                     ntracks++;
 301                 }else if(tidx[j] != fTrack[ntracks-1]){
 302                     ntracks++;
 303                     if(ntracks > 9) {
 304                         bit = 1;
 305                         break;
 306                     } // end if ntracks > 9
 307                     fTrack[ntracks-1] = tidx[j];
 308                 } // end if ntracke == 0
 309             } // end if tidx[j] >=0
 310         } // 3-tracks loop for the digit
 311         if(bit == 1) break;
 312     } // digit loop
 313
 314     SetNTracks(ntracks);
 315     nt = ntracks;
 316     return &(fTrack[0]);
 317 */
 318 }
 319 //______________________________________________________________________
 320 Double_t AliITSclusterSSD::GetPosition(){
 321     // return position of the cluster
 322     Float_t ret;
 323
 324     switch(fNDigits){
 325     case  1:
 326         ret = GetDigitStripNo(0);
 327         break;
 328     case  2:
 329         ret = EtaAlgorithm();
 330         break;
 331     default:
 332         ret = CentrOfGravity();
 333     }
 334     return ret;
 335 }
 336 //______________________________________________________________________
 337 Double_t AliITSclusterSSD::EtaAlgorithm(){
 338     // algorithm for determing cluster position
 339     if (fNDigits != 2) return -1;
 340
 341     Int_t strip1  = GetDigit(0)->GetStripNumber();
 342     Int_t strip2  = GetDigit(1)->GetStripNumber();
 343     Int_t signal1 = GetDigit(0)->GetSignal();
 344     Int_t signal2 = GetDigit(1)->GetSignal();
 345
 346     Double_t eta;
 347
 348
 349     if (strip1<strip2){
 350         eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
 351         if (eta<0.04) return strip1;
 352         if (eta>0.96) return strip2;
 353         return (strip1 + 0.43478261*eta + 0.2826087);
 354     } else{
 355         eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
 356         if (eta<0.04) return strip2;
 357         if (eta>0.96) return strip1;
 358         return (strip2 + 0.43478261*eta + 0.2826087);
 359     }
 360 }
 361 //______________________________________________________________________
 362 Double_t  AliITSclusterSSD::GetPositionError(){
 363     // return the position error
 364     return (GetNumOfDigits()+1)/2;
 365 }
 366 //______________________________________________________________________
 367 Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx){
 368     // return the cluster to which he crosses
 369
 370     for (Int_t i =0; i< fNCrosses;i++){
 371         if (GetCross(i) == idx) return kTRUE;
 372     }
 373     return kFALSE;
 374 }