[u/mrichter/AliRoot.git] / ITS / AliITSclusterSSD.cxx

#include <iostream.h>
#include "AliITSdigit.h"
#include "AliITSclusterSSD.h"

ClassImp(AliITSclusterSSD)

AliITSclusterSSD::AliITSclusterSSD()
{
  // default constructor

	fSide        = kTRUE;
	fDigits      = 0;
	fNDigits     = 0;
	fDigitsIndex = 0;
        fNCrosses    = 0;
	fTotalSignal = -1;
	fNTracks      = -1;
	fLeftNeighbour  = kFALSE;
	fRightNeighbour = kFALSE;
	fCrossedClusterIndexes = 0;
	fConsumed=kFALSE;

}
/*************************************************************************/

AliITSclusterSSD::AliITSclusterSSD
  (Int_t ndigits, Int_t *DigitIndexes, 
   TObjArray *Digits, Bool_t side)
{
  // non-default constructor

	fNDigits = ndigits;
	fDigits = Digits;
	fSide = side;
	fDigitsIndex = new TArrayI(fNDigits,DigitIndexes );	
	fNCrosses    = 0;
	fCrossedClusterIndexes = new TArrayI(300);
	fLeftNeighbour  = kFALSE;
	fRightNeighbour = kFALSE;
	fTotalSignal =-1;
	fNTracks    = -1;
        fConsumed=kFALSE;
}
/*************************************************************************/
AliITSclusterSSD::~AliITSclusterSSD()
{
  // destructor
  delete fDigitsIndex;
  delete fCrossedClusterIndexes;
}
 
/*************************************************************************/
AliITSclusterSSD::AliITSclusterSSD(const AliITSclusterSSD &OneSCluster)
{
  // copy constructor

  if (this == &OneSCluster) return;
  fNDigits = OneSCluster.fNDigits;
  fSide=OneSCluster.fSide;
  fDigits=OneSCluster.fDigits;
  fDigitsIndex = new TArrayI(fNDigits);
  fLeftNeighbour  = OneSCluster.fLeftNeighbour;
  fRightNeighbour = OneSCluster.fRightNeighbour;
  fTotalSignal =-1;
  fNTracks     = -1;
  fNCrosses = OneSCluster.fNCrosses;
  fConsumed = OneSCluster.fConsumed;
  Int_t i;
  for (i = 0; i< fNCrosses ; i++)
   {
     fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
   }
  for (i = 0; i< fNDigits ; i++)
  {
    fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
  }
  return;
}	

/*************************************************************************/
AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSCluster)
{
  // assignment operator

  if (this == &OneSCluster) return *this;
  fNDigits = OneSCluster.fNDigits;
  fSide=OneSCluster.fSide;
  fDigits=OneSCluster.fDigits;
  fDigitsIndex = new TArrayI(fNDigits);
  fLeftNeighbour  = OneSCluster.fLeftNeighbour;
  fRightNeighbour = OneSCluster.fRightNeighbour;
  fTotalSignal =-1;
  fNTracks     = -1;
  fNCrosses = OneSCluster.fNCrosses;
  fConsumed = OneSCluster.fConsumed;
  Int_t i;
  for (i = 0; i< fNCrosses ; i++)
   {
     fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
   }
  for (i = 0; i< fNDigits ; i++)
  {
    fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
  }
  return *this;
}	

/*************************************************************************/
Int_t AliITSclusterSSD::SplitCluster(Int_t where, Int_t *outdigits)
{
//This methods generate data necessery to make new object of this class
//I choosen this way, because methods TClonesArray::Add* dont work
//so I have to use constraction: new (a[i]) Creator(params...);
//where 'a' is a TClonesArray 
//This method generate params - see AliITSmoduleSSD::SplitCluster;
		
	
  Int_t tmp = fNDigits;
  Int_t ind = 0;
    outdigits[ind++]=(*fDigitsIndex)[where];
                     //coping border strip (it is shared by this two clusters)
    for (Int_t i = (where+1); i < tmp; i++)
     {
       outdigits[ind++]=(*fDigitsIndex)[i];  //"moving" strips from this to the new one 
       (*fDigitsIndex)[i]=-1;   
       fNDigits--;   //deleting strips from this cluster
     } 
  return ind;		
}
		
/*******************************************************************/
Int_t AliITSclusterSSD::GetDigitStripNo(Int_t digit)
{
  // return strip no of a digit
	if (digit<0) return -1;
	return (digit>(fNDigits-1))?-1 :
      //PH            ((AliITSdigitSSD*)((*fDigits)[(*fDigitsIndex)[digit]]))->GetStripNumber();
            ((AliITSdigitSSD*)(fDigits->At((*fDigitsIndex)[digit])))->GetStripNumber();
}
/************************************************************/
Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit)
{
  // returns digit signal
  Int_t index,signal;
  if (digit<0||digit>=fNDigits) return -1;
  index  = (*fDigitsIndex)[digit];
  //PH  signal = ((AliITSdigitSSD*)((*fDigits)[index]))->GetSignal();
  signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
  /*
  if(signal>1.e5) printf("GetDigitSignal: digit %d index %d signal %d\n",
			 digit,index, signal);
  */
  return  signal;
}

/***********************************************************/
void  AliITSclusterSSD::AddCross(Int_t clIndex)
{
  // add cluster cross to list of cluster crosses
  
	(*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
}
/***********************************************************/

Int_t AliITSclusterSSD::GetCross(Int_t crIndex)
{
  // return crossing cluster
  
  return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
}
/***********************************************************/
Double_t AliITSclusterSSD::CentrOfGravity()
{
  // return center of gravity of the cluster
  Float_t ret=0;
  
  if (fLeftNeighbour) ret+=(GetDigitStripNo(0)*0.5*GetDigitSignal(0));
      else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
  
  if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)*0.5*GetDigitSignal(fNDigits -1));
      else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
      
  for (Int_t i=1;i<fNDigits-1;i++)
    {
      ret +=GetDigitStripNo(i)*GetDigitSignal(i);
    }
  
  if (fTotalSignal<0) GetTotalSignal();
	
    return (ret/fTotalSignal);
}

/***********************************************************/
Float_t AliITSclusterSSD::GetTotalSignal()
{
  // return total signal
  
  if(fTotalSignal <0)
    {
      fTotalSignal=0;
      if (fNDigits ==1)  {
          fTotalSignal = (Float_t)GetDigitSignal(0);
	  //printf("1 digit: signal %d \n",GetDigitSignal(0)); 
	  return fTotalSignal;
      }

      if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
      else fTotalSignal += (Float_t) GetDigitSignal(0);
      //printf("GetTotalSignal :i  DigitSignal %d %d \n",0,GetDigitSignal(0)); 
		
      if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(fNDigits -1));
      else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
      //printf("GetTotalSignal :i  DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1)); 
				
      for (Int_t i = 1;i<fNDigits -1;i++) 
        {
      	  fTotalSignal += (Float_t)GetDigitSignal(i);
	  //printf("GetTotalSignal :i  DigitSignal %d %d \n",i,GetDigitSignal(i)); 
      	}
      //printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal); 
    }
   return fTotalSignal;
}
/***********************************************************/

Float_t  AliITSclusterSSD::GetTotalSignalError()
{
  // return the error on the signal
  Float_t err =0;
  for (Int_t i =1; i<fNDigits -1; i++)
    {
      err+=0.1*GetDigitSignal(i);   
    } 
  if (GetLeftNeighbour())
   {
    err+=GetDigitSignal(0);
   }
  else
   {
    err+=0.1*GetDigitSignal(0);
   } 
  if (GetRightNeighbour())
   {
    err+=GetDigitSignal(fNDigits -1);
   }
  else
   {
    err+=0.1*GetDigitSignal(fNDigits -1);
   }
  return err; 
   
}

/***********************************************************/

void AliITSclusterSSD::DelCross(Int_t index)
{
  // remove cross clusters from the list of cross clusters
Int_t i,j; //iterators

for (i =0;i<fNCrosses;i++)
 {
  if ((*fCrossedClusterIndexes)[i] == index)
   {
     for (j=i;j<fNCrosses-1;j++)
      {
        (*fCrossedClusterIndexes)[j]=(*fCrossedClusterIndexes)[j+1];
      }
     fNCrosses--;
     return; 
   }
 }

}
/***********************************************************/

Int_t  *AliITSclusterSSD::GetTracks(Int_t &nt)
{
  // return the track number of the cluster
  Int_t *tidx=0;
  Int_t i, j;
  Int_t bit =0;
  Int_t ntracks=0;
  nt=0;

  for (i=0;i<10;i++) {
       fTrack[i] = -2;
  }
   
  //cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;

  for (i = 0; i<fNDigits; i++) {
     tidx=GetDigit(i)->GetTracks();
     for (j = 0; j<3;j++) {
       if (tidx[j] >= 0) {
	 if(ntracks == 0){
         ntracks++; 
         fTrack[ntracks-1] = tidx[j];
	 }else if(tidx[j] != fTrack[ntracks-1]){
          ntracks++; 
          if(ntracks > 9) {
           bit = 1;
           break;
	  }
          fTrack[ntracks-1] = tidx[j];
	 }
       }
       //cout<<"digit,dtrack,tidx,bit ="<<i<<","<<j<<","<<tidx[j]<<","<<bit<<endl; 
       //if(ntracks>0) cout<<"digit,dtrack,fTrack,ntracks ="<<i<<","<<j<<","<<fTrack[ntracks-1]<<","<<ntracks<<endl; 
     } // 3-tracks loop for the digit 
     if(bit == 1) break;
  } // digit loop

  SetNTracks(ntracks); 
  nt = ntracks;
  //if(nt == 0) cout<<"!!! No tracks"<<endl;
  //cout<<"GetTracks: nt,fTrack0,fTrack1,fTrack2 ="<< nt<<","<<fTrack[0]<<","<<fTrack[1]<<","<<fTrack[2]<<endl;
 return &(fTrack[0]);
}
/***********************************************************/

Double_t AliITSclusterSSD::GetPosition()
{
  // return position of the cluster
  Float_t ret;
  switch(fNDigits)
   {
     case  1:
       ret = GetDigitStripNo(0);
       break;
     case  2:
       ret = EtaAlgorithm();
       break;       
     default:
       ret = CentrOfGravity();   
   }
  return ret;
}

/***********************************************************/

Double_t AliITSclusterSSD::EtaAlgorithm()
{
  // algorithm for determing cluster position
  if (fNDigits != 2) return -1;

  Int_t strip1  = GetDigit(0)->GetStripNumber(); 
  Int_t strip2  = GetDigit(1)->GetStripNumber();
  Int_t signal1 = GetDigit(0)->GetSignal();
  Int_t signal2 = GetDigit(1)->GetSignal();

  Double_t eta;
  
 
  if (strip1<strip2)
   {
    eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
    if (eta<0.04) return strip1;
    if (eta>0.96) return strip2;
    return (strip1 + 0.43478261*eta + 0.2826087);   
   }
  else
  {
    eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
    if (eta<0.04) return strip2;
    if (eta>0.96) return strip1;
    return (strip2 + 0.43478261*eta + 0.2826087);   
  }

 
}

Double_t  AliITSclusterSSD::GetPositionError()
{
  // return the position error
 return (GetNumOfDigits()+1)/2;
}

Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx)
{
  // return the cluster to which he crosses
 for (Int_t i =0; i< fNCrosses;i++)
  {
    if (GetCross(i) == idx) return kTRUE;
  }
 return kFALSE;
}
Commit	Line	Data
b0f5e3fc	1	#include <iostream.h>
e8189707	2	#include "AliITSdigit.h"
b0f5e3fc	3	#include "AliITSclusterSSD.h"
	4
	5	ClassImp(AliITSclusterSSD)
	6
	7	AliITSclusterSSD::AliITSclusterSSD()
	8	{
	9	// default constructor
f239b2fe	10
e8189707	11	fSide = kTRUE;
b0f5e3fc	12	fDigits = 0;
	13	fNDigits = 0;
	14	fDigitsIndex = 0;
	15	fNCrosses = 0;
	16	fTotalSignal = -1;
f239b2fe	17	fNTracks = -1;
b0f5e3fc	18	fLeftNeighbour = kFALSE;
b0f5e3fc	19	fRightNeighbour = kFALSE;
cd77595e	20	fCrossedClusterIndexes = 0;
b0f5e3fc	21	fConsumed=kFALSE;
	22
	23	}
	24	/*************************************************************************/
	25
	26	AliITSclusterSSD::AliITSclusterSSD
	27	(Int_t ndigits, Int_t *DigitIndexes,
	28	TObjArray *Digits, Bool_t side)
	29	{
766ef0c8	30	// non-default constructor
f239b2fe	31
b0f5e3fc	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;
f239b2fe	41	fNTracks = -1;
b0f5e3fc	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
f239b2fe	56
b0f5e3fc	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;
f239b2fe	65	fNTracks = -1;
b0f5e3fc	66	fNCrosses = OneSCluster.fNCrosses;
	67	fConsumed = OneSCluster.fConsumed;
	68	Int_t i;
e8189707	69	for (i = 0; i< fNCrosses ; i++)
b0f5e3fc	70	{
	71	fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
	72	}
e8189707	73	for (i = 0; i< fNDigits ; i++)
b0f5e3fc	74	{
	75	fDigitsIndex[i]=OneSCluster.fDigitsIndex[i];
	76	}
	77	return;
	78	}
	79
	80	/*************************************************************************/
	81	AliITSclusterSSD& AliITSclusterSSD::operator=(const AliITSclusterSSD & OneSCluster)
	82	{
	83	// assignment operator
f239b2fe	84
b0f5e3fc	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;
f239b2fe	93	fNTracks = -1;
b0f5e3fc	94	fNCrosses = OneSCluster.fNCrosses;
	95	fConsumed = OneSCluster.fConsumed;
	96	Int_t i;
e8189707	97	for (i = 0; i< fNCrosses ; i++)
b0f5e3fc	98	{
	99	fCrossedClusterIndexes[i] = OneSCluster.fCrossedClusterIndexes[i];
	100	}
e8189707	101	for (i = 0; i< fNDigits ; i++)
b0f5e3fc	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)
e8189707	122	for (Int_t i = (where+1); i < tmp; i++)
b0f5e3fc	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	{
766ef0c8	134	// return strip no of a digit
b0f5e3fc	135	if (digit<0) return -1;
b0f5e3fc	136	return (digit>(fNDigits-1))?-1 :
2682e810	137	//PH ((AliITSdigitSSD)((fDigits)[(*fDigitsIndex)[digit]]))->GetStripNumber();
2682e810	138	((AliITSdigitSSD)(fDigits->At((fDigitsIndex)[digit])))->GetStripNumber();
b0f5e3fc	139	}
	140	/************************************************************/
	141	Int_t AliITSclusterSSD::GetDigitSignal(Int_t digit)
	142	{
b0f5e3fc	143	// returns digit signal
766ef0c8	144	Int_t index,signal;
b0f5e3fc	145	if (digit<0\|\|digit>=fNDigits) return -1;
b0f5e3fc	146	index = (*fDigitsIndex)[digit];
2682e810	147	//PH signal = ((AliITSdigitSSD)((fDigits)[index]))->GetSignal();
2682e810	148	signal = ((AliITSdigitSSD*)(fDigits->At(index)))->GetSignal();
b0f5e3fc	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	/***********************************************************/
	157	void AliITSclusterSSD::AddCross(Int_t clIndex)
	158	{
766ef0c8	159	// add cluster cross to list of cluster crosses
766ef0c8	160
b0f5e3fc	161	(*fCrossedClusterIndexes)[fNCrosses++] = clIndex;
	162	}
	163	/***********************************************************/
	164
	165	Int_t AliITSclusterSSD::GetCross(Int_t crIndex)
	166	{
766ef0c8	167	// return crossing cluster
766ef0c8	168
b0f5e3fc	169	return ((crIndex>-1)&&(crIndex<fNCrosses))?(*fCrossedClusterIndexes)[crIndex]:-1;
	170	}
	171	/***********************************************************/
	172	Double_t AliITSclusterSSD::CentrOfGravity()
	173	{
766ef0c8	174	// return center of gravity of the cluster
b0f5e3fc	175	Float_t ret=0;
	176
	177	if (fLeftNeighbour) ret+=(GetDigitStripNo(0)0.5GetDigitSignal(0));
	178	else ret+=(GetDigitStripNo(0)*GetDigitSignal(0));
	179
	180	if (fRightNeighbour) ret+=(GetDigitStripNo(fNDigits -1)0.5GetDigitSignal(fNDigits -1));
	181	else ret+=(GetDigitStripNo(fNDigits -1)*GetDigitSignal(fNDigits-1));
e8189707	182
e8189707	183	for (Int_t i=1;i<fNDigits-1;i++)
b0f5e3fc	184	{
	185	ret +=GetDigitStripNo(i)*GetDigitSignal(i);
	186	}
	187
	188	if (fTotalSignal<0) GetTotalSignal();
	189
	190	return (ret/fTotalSignal);
	191	}
	192
	193	/***********************************************************/
	194	Float_t AliITSclusterSSD::GetTotalSignal()
	195	{
766ef0c8	196	// return total signal
766ef0c8	197
b0f5e3fc	198	if(fTotalSignal <0)
	199	{
	200	fTotalSignal=0;
	201	if (fNDigits ==1) {
	202	fTotalSignal = (Float_t)GetDigitSignal(0);
	203	//printf("1 digit: signal %d \n",GetDigitSignal(0));
	204	return fTotalSignal;
	205	}
	206
	207	if (fLeftNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(0));
	208	else fTotalSignal += (Float_t) GetDigitSignal(0);
	209	//printf("GetTotalSignal :i DigitSignal %d %d \n",0,GetDigitSignal(0));
	210
	211	if (fRightNeighbour) fTotalSignal += (Float_t)(0.5*GetDigitSignal(fNDigits -1));
	212	else fTotalSignal += (Float_t)GetDigitSignal(fNDigits-1);
	213	//printf("GetTotalSignal :i DigitSignal %d %d \n",fNDigits -1,GetDigitSignal(fNDigits -1));
e8189707	214
e8189707	215	for (Int_t i = 1;i<fNDigits -1;i++)
b0f5e3fc	216	{
	217	fTotalSignal += (Float_t)GetDigitSignal(i);
	218	//printf("GetTotalSignal :i DigitSignal %d %d \n",i,GetDigitSignal(i));
	219	}
	220	//printf("GetTotalSignal: fNDigits %d fTotalSignal %.0f \n",fNDigits,fTotalSignal);
	221	}
	222	return fTotalSignal;
	223	}
	224	/***********************************************************/
	225
	226	Float_t AliITSclusterSSD::GetTotalSignalError()
	227	{
766ef0c8	228	// return the error on the signal
b0f5e3fc	229	Float_t err =0;
e8189707	230	for (Int_t i =1; i<fNDigits -1; i++)
b0f5e3fc	231	{
	232	err+=0.1*GetDigitSignal(i);
	233	}
	234	if (GetLeftNeighbour())
	235	{
	236	err+=GetDigitSignal(0);
	237	}
	238	else
	239	{
	240	err+=0.1*GetDigitSignal(0);
	241	}
	242	if (GetRightNeighbour())
	243	{
	244	err+=GetDigitSignal(fNDigits -1);
	245	}
	246	else
	247	{
	248	err+=0.1*GetDigitSignal(fNDigits -1);
	249	}
	250	return err;
	251
	252	}
	253
	254	/***********************************************************/
	255
	256	void AliITSclusterSSD::DelCross(Int_t index)
	257	{
766ef0c8	258	// remove cross clusters from the list of cross clusters
b0f5e3fc	259	Int_t i,j; //iterators
b0f5e3fc	260
e8189707	261	for (i =0;i<fNCrosses;i++)
b0f5e3fc	262	{
	263	if ((*fCrossedClusterIndexes)[i] == index)
	264	{
e8189707	265	for (j=i;j<fNCrosses-1;j++)
b0f5e3fc	266	{
	267	(fCrossedClusterIndexes)[j]=(fCrossedClusterIndexes)[j+1];
	268	}
	269	fNCrosses--;
	270	return;
	271	}
	272	}
	273
	274	}
	275	/***********************************************************/
	276
	277	Int_t *AliITSclusterSSD::GetTracks(Int_t &nt)
	278	{
766ef0c8	279	// return the track number of the cluster
b0f5e3fc	280	Int_t *tidx=0;
f239b2fe	281	Int_t i, j;
	282	Int_t bit =0;
	283	Int_t ntracks=0;
b0f5e3fc	284	nt=0;
b0f5e3fc	285
f239b2fe	286	for (i=0;i<10;i++) {
	287	fTrack[i] = -2;
	288	}
b0f5e3fc	289
f239b2fe	290	//cout<<"GetTrack start -------: fNDigits ="<<fNDigits<<endl;
b0f5e3fc	291
f239b2fe	292	for (i = 0; i<fNDigits; i++) {
	293	tidx=GetDigit(i)->GetTracks();
	294	for (j = 0; j<3;j++) {
	295	if (tidx[j] >= 0) {
	296	if(ntracks == 0){
	297	ntracks++;
	298	fTrack[ntracks-1] = tidx[j];
	299	}else if(tidx[j] != fTrack[ntracks-1]){
	300	ntracks++;
	301	if(ntracks > 9) {
	302	bit = 1;
	303	break;
	304	}
	305	fTrack[ntracks-1] = tidx[j];
	306	}
	307	}
	308	//cout<<"digit,dtrack,tidx,bit ="<<i<<","<<j<<","<<tidx[j]<<","<<bit<<endl;
	309	//if(ntracks>0) cout<<"digit,dtrack,fTrack,ntracks ="<<i<<","<<j<<","<<fTrack[ntracks-1]<<","<<ntracks<<endl;
	310	} // 3-tracks loop for the digit
	311	if(bit == 1) break;
	312	} // digit loop
	313
	314	SetNTracks(ntracks);
	315	nt = ntracks;
	316	//if(nt == 0) cout<<"!!! No tracks"<<endl;
	317	//cout<<"GetTracks: nt,fTrack0,fTrack1,fTrack2 ="<< nt<<","<<fTrack[0]<<","<<fTrack[1]<<","<<fTrack[2]<<endl;
b0f5e3fc	318	return &(fTrack[0]);
	319	}
	320	/***********************************************************/
	321
	322	Double_t AliITSclusterSSD::GetPosition()
	323	{
766ef0c8	324	// return position of the cluster
b0f5e3fc	325	Float_t ret;
	326	switch(fNDigits)
	327	{
	328	case 1:
	329	ret = GetDigitStripNo(0);
	330	break;
	331	case 2:
	332	ret = EtaAlgorithm();
	333	break;
	334	default:
	335	ret = CentrOfGravity();
	336	}
	337	return ret;
	338	}
	339
	340	/***********************************************************/
	341
	342	Double_t AliITSclusterSSD::EtaAlgorithm()
	343	{
766ef0c8	344	// algorithm for determing cluster position
b0f5e3fc	345	if (fNDigits != 2) return -1;
	346
	347	Int_t strip1 = GetDigit(0)->GetStripNumber();
	348	Int_t strip2 = GetDigit(1)->GetStripNumber();
	349	Int_t signal1 = GetDigit(0)->GetSignal();
	350	Int_t signal2 = GetDigit(1)->GetSignal();
	351
	352	Double_t eta;
	353
	354
	355	if (strip1<strip2)
	356	{
	357	eta = ((Double_t)signal2)/((Double_t)(signal1+signal2));
	358	if (eta<0.04) return strip1;
	359	if (eta>0.96) return strip2;
	360	return (strip1 + 0.43478261*eta + 0.2826087);
	361	}
	362	else
	363	{
	364	eta = ((Double_t)signal1)/((Double_t)(signal1+signal2));
	365	if (eta<0.04) return strip2;
	366	if (eta>0.96) return strip1;
	367	return (strip2 + 0.43478261*eta + 0.2826087);
	368	}
	369
	370
	371	}
	372
	373	Double_t AliITSclusterSSD::GetPositionError()
	374	{
766ef0c8	375	// return the position error
b0f5e3fc	376	return (GetNumOfDigits()+1)/2;
	377	}
	378
	379	Bool_t AliITSclusterSSD::IsCrossingWith(Int_t idx)
	380	{
766ef0c8	381	// return the cluster to which he crosses
e8189707	382	for (Int_t i =0; i< fNCrosses;i++)
b0f5e3fc	383	{
	384	if (GetCross(i) == idx) return kTRUE;
	385	}
	386	return kFALSE;
	387	}