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