ITS/AliITSclusterSSD.cxx

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