ITS/AliITSclusterSSD.cxx

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