[u/mrichter/AliRoot.git] / TPC / AliSimDigits.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/*
$Log$
Revision 1.1.4.2  2000/04/10 11:37:42  kowal2

Digits handling in a new data structure

*/


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Alice segment manager object                                             //
//                                
//  AliSimDigits object   (derived from AliDigits)                            //
//  provide additional track information to digit                            //
//  
//   Origin: Marian Ivanov  GSI Darmstadt                                     //
//
//                                                                           //
//                                                                          //
///////////////////////////////////////////////////////////////////////////////

#include "TClass.h"
#include <iostream.h>
#include "TError.h"
#include "AliSegmentID.h"
#include "AliH2F.h"
#include "AliArrayI.h"
#include "AliArrayS.h"
#include "AliDigits.h"
#include "AliSimDigits.h"
#include "AliTPC.h"


//_____________________________________________________________________________
//_____________________________________________________________________________
//_____________________________________________________________________________
ClassImp(AliSimDigits)

AliSimDigits::AliSimDigits()
{
  //  AliDigits::Invalite();
  fTracks = 0;
  fTrIndex = 0;  
  InvalidateTrack();
}
AliSimDigits::~AliSimDigits()
{
  //  AliDigits::Invalidate();
  if (fTracks != 0) fTracks->Delete();
  if (fTrIndex != 0) fTrIndex->Delete();  

}

void AliSimDigits::InvalidateTrack() 
{ 
  //
  //set default (invalid parameters)
  if ( fTracks != 0) delete fTracks;
  fTracks = new AliArrayI;
  if ( fTrIndex  != 0) delete fTrIndex;
  fTrIndex = new AliArrayI;

  for (Int_t i = 0; i<3; i++){
    fTracks->Set(0);
    fTrIndex->Set(0);
  }
}

void  AliSimDigits::AllocateTrack(Int_t length)
{
  //
  //construct empty buffer fElements and fTracks with size fNrows x fNcols x
  //length 
  InvalidateTrack();
  fNlevel = length;
  fTracks->Set(fNcols*fNrows*fNlevel);
  fTrIndex->Set(0); 
  fTrBufType =0;
}

Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level) 
{
  //
  //Get track ID 
  if (fTrBufType == 0) return  GetTrackIDFast(row, column,level);
  if (fTrBufType == 1) return  GetTrackID1(row, column,level); 
  if (fTrBufType == 2) return  GetTrackID2(row, column,level); 
  return 0;
}

void AliSimDigits::ExpandTrackBuffer()
{  
  //
  //expand buffer to two dimensional array 
  if (fTrBufType<0)  {
    Error("ExpandBuffer", "buffer doesn't exist");
    return;
  }
  if (fTrBufType==0)      return;  //buffer expanded
  if (fTrBufType==1)  {ExpandTrackBuffer1(); return;}
  if (fTrBufType==2)  ExpandTrackBuffer2();
 
}

void AliSimDigits::CompresTrackBuffer(Int_t bufType)
{
  //
  //compres buffer according buffertype algorithm
  //
  if (fTrBufType<0)  {
    Error("CompressBuffer", "buffer doesn't exist");
    return;
  }
  if (fTrBufType == bufType) return;
  //
  if (fTrBufType>0) ExpandTrackBuffer();
  if (fTrBufType !=0)  {
    Error("CompressBuffer", "buffer doesn't exist");
    return;
  }
  //compress buffer of type 1
  
  if (bufType==1)      {CompresTrackBuffer1();return;}
  if (bufType==2)      CompresTrackBuffer2();
   
}

Int_t  AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
{
  //return  track ID of digits - for buffer compresion 2
  Int_t i,n1,n2;
  i = level*fNcols+column;
  if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
  else 
    n2 = fTrIndex->At(i+1);
  n1 = fTrIndex->At(i);
  Int_t rownew = 0;
  Int_t rowold=0;
  Int_t ID;
  for (i = n1;(i<n2);i++){
    ID = 0;
    Int_t num = fTracks->At(i);
    if (num<0) {
      rownew-=num;  
      rowold = rownew;
      i++;
      if (i<n2){
	num = fTracks->At(i);
	rownew+=num;
	i++;
	ID = fTracks->At(i);
      }
    }
    else {
      rowold = rownew;
      rownew+=num;
      i++;
      ID = fTracks->At(i);
    }
ID-=2;
    if ( (row>=rowold) && (row<=rownew) ) return ID;
    if (row < rownew ) return -2; //empty track
  }
  return -2;
}

void  AliSimDigits::ExpandTrackBuffer1()
{
  //
  //expand  track compressed according algorithm 1 (track ID comression independent to the digit compression)
  // !!in expanded tracks we don't use fTrIndex array
  //  
  fTrBufType = 0;
  Int_t i,j;
  Int_t all   = fNrows*fNcols;  //total number of digits
  Int_t elems = all*fNlevel;  //length of the buffer

  AliArrayI * buf = new AliArrayI;
  buf->Set(elems);
  fTrIndex->Set(0);
  //
  Int_t level = 0;
  Int_t col=0;
  Int_t row = 0;
  Int_t N=fTracks->fN;
  //
  for (i=0;i<N;i++){
    //oposite signa means how many unwrited (under threshold) values
    Int_t num = fTracks->At(i);
    if (num<0) row-=num;   //negative number mean number of zeroes (no tracks of gibven level no need to write to array) 
    else {
      i++;
      Int_t ID =  fTracks->At(i);
      for (j = 0; j<num; j++,row++) (*buf)[level*all+col*fNrows+row]=ID;       
    }
    if (row>=fNrows) {
      row=0;
      col++;
    }
    if (col>=fNcols) {
      col=0;
      level++;
    }    
  }//end of loop over digits
  delete fTracks;
  fTracks = buf;
}

void  AliSimDigits::CompresTrackBuffer1()
{
  //
  //comress track according algorithm 1 (track ID comression independent to the digit compression)
  //
  fTrBufType = 1;  

  AliArrayI *  buf = new AliArrayI;   //create  new buffer 
  buf->Set(fNrows*fNcols*fNlevel); //lets have the nearly the "worst case"
  AliArrayI *  index = new AliArrayI;
  index->Set(fNcols*fNlevel);

  Int_t icurrent=-1;  //current index
  Int_t izero;      //number of zero
  Int_t inum;      //number of digits  with the same current track ID  
  Int_t lastID =0;  //last track ID
  for (Int_t lev =0; lev<fNlevel; lev++){    //loop over levels 
    for (Int_t col = 0; col<fNcols; col++){    //loop over columns
      izero = 0;
      inum =  0;
      lastID = 0;
      (*index)[lev*fNcols+col]=icurrent+1;//set collumn pointer
      Int_t ID;  //current ID
      for (Int_t row = 0; row< fNrows;row++){ //loop over rows
	ID = GetTrackIDFast(row,col,lev);
	if (ID <= 0) {
	  if ( inum> 0 ) { //if we have some tracks in buffer
	    icurrent++;
	    if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
	    (*buf)[icurrent] = inum;
	    icurrent++;
	    (*buf)[icurrent] = lastID;	
	    inum = 0;      
	    lastID = 0;
	  }
	  izero++;
	}
	else
          if (ID != lastID) 
	    if ( izero > 0 ) { 
	      //if we have currently izero count of non tracks digits
	      icurrent++;	  
	      if (icurrent>=buf->fN) buf->Expand(icurrent*2);
	      (*buf)[icurrent]= -izero;  //write how many under zero
	      inum++;
	      izero = 0;	     
	      lastID = ID;
	    }
	    else{ 
	      //if we change track ID from another track ID	    
	      icurrent++;	  
	      if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
	      (*buf)[icurrent] = inum;
	      icurrent++;
	      (*buf)[icurrent] = lastID;	
	      lastID = ID;
	      inum = 1;      
	      izero = 0;
	    }	
	  else {	  
	    inum++;
	  }
	
      }//end of loop over rows
      if ( izero > 0 ) { 
	//if we have currently izero count of non tracks digits
	icurrent++;	  
	if (icurrent>=buf->fN) buf->Expand(icurrent*2);
	(*buf)[icurrent]= -izero;  //write how many under zero	
      }
      if ( inum> 0 ) { //if we have some tracks in buffer
	icurrent++;
	if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
	(*buf)[icurrent] = inum;
	icurrent++;
	(*buf)[icurrent] = ID;	
      }      
    }//end of loop over columns
  }//end of loop over differnet track level  
  buf->Expand(icurrent+1);
  delete fTracks;
  fTracks = buf;
  delete fTrIndex;
  fTrIndex = index;
}


void  AliSimDigits::ExpandTrackBuffer2()
{
  //
  //comress track according algorithm 2 (track ID comression according  digit compression)
  fTrBufType = 0;
}

void  AliSimDigits::CompresTrackBuffer2()
{
  //
  //comress track according algorithm 2 (track ID comression according  digit compression)
  fTrBufType = 2;
}


Int_t  AliSimDigits::GetTrackID2(Int_t row, Int_t column, Int_t level)
{
  //returnb track ID of digits - for buffer compresion 2
  return -2;
}


AliH2F *  AliSimDigits::DrawTracks( const char *option,Int_t level, 
			      Float_t x1, Float_t x2, Float_t y1, Float_t y2)
{
  //
  //draw digits in given array
  //  
  //make digits histo 
  char ch[30];
  sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
  if ( (fNrows<1)|| (fNcols<1)) {
    return 0;
  }
  AliH2F * his  = new AliH2F("Track histo",ch,fNrows,0,fNrows,fNcols,0,fNcols);
  ExpandTrackBuffer();
  //set histogram  values
  for (Int_t i = 0; i<fNrows;i++)    
    for (Int_t j = 0; j<fNcols;j++)
        his->Fill(i,j,GetTrackIDFast(i,j,level));
  if (x1>=0) {
      AliH2F *h2fsub = his->GetSubrange2d(x1,x2,y1,y2);
      delete his;
      his=h2fsub;
  }
  if (his==0) return 0;
  if (option!=0) his->Draw(option);
  else his->Draw();
  return his;  
}

TClonesArray *  AliSimDigits::GenerTPCClonesArray(TClonesArray * arr)
{
  //
  //generate TClonnesArray of digits
  //
  TClonesArray * digits;
  if (arr==0)  digits=new TClonesArray("AliTPCdigit",300);
  else digits = arr; 
  Int_t index = digits->GetEntriesFast();
  for (Int_t row =0; row<fNrows; row++)
    for (Int_t col =0; col<fNcols; col++){
      Int_t amp = GetDigit(row,col);
      if (amp>GetThreshold()){
	AliTPCdigit dig;
	dig.fPad = col;
	dig.fTime = row;
	dig.fSignal= amp;
	dig.fPadRow =fSegmentID;
	dig.fSector =fSegmentID;
	dig.fTracks[0]= GetTrackID(row,col,0);
	dig.fTracks[1]= GetTrackID(row,col,1);
	dig.fTracks[2]= GetTrackID(row,col,2);
	TClonesArray &ldigits = *digits;
	new(ldigits[index++]) AliTPCdigit(dig);
      }
    }    
  return digits;
}
Commit	Line	Data
cc80f89e	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	/*
	17	$Log$
	18	Revision 1.1.4.2 2000/04/10 11:37:42 kowal2
	19
	20	Digits handling in a new data structure
	21
	22	*/
	23
	24
	25	///////////////////////////////////////////////////////////////////////////////
	26	// //
	27	// Alice segment manager object //
	28	//
	29	// AliSimDigits object (derived from AliDigits) //
	30	// provide additional track information to digit //
	31	//
	32	// Origin: Marian Ivanov GSI Darmstadt //
	33	//
	34	// //
	35	// //
	36	///////////////////////////////////////////////////////////////////////////////
	37
	38	#include "TClass.h"
	39	#include <iostream.h>
	40	#include "TError.h"
	41	#include "AliSegmentID.h"
	42	#include "AliH2F.h"
	43	#include "AliArrayI.h"
	44	#include "AliArrayS.h"
	45	#include "AliDigits.h"
	46	#include "AliSimDigits.h"
	47	#include "AliTPC.h"
	48
	49
	50
	51	//_____________________________________________________________________________
	52	//_____________________________________________________________________________
	53	//_____________________________________________________________________________
	54	ClassImp(AliSimDigits)
	55
	56	AliSimDigits::AliSimDigits()
	57	{
	58	// AliDigits::Invalite();
	59	fTracks = 0;
	60	fTrIndex = 0;
	61	InvalidateTrack();
	62	}
	63	AliSimDigits::~AliSimDigits()
	64	{
65	// AliDigits::Invalidate();
66	if (fTracks != 0) fTracks->Delete();
67	if (fTrIndex != 0) fTrIndex->Delete();
68
69	}
70
71	void AliSimDigits::InvalidateTrack()
72	{
73	//
74	//set default (invalid parameters)
75	if ( fTracks != 0) delete fTracks;
76	fTracks = new AliArrayI;
77	if ( fTrIndex != 0) delete fTrIndex;
78	fTrIndex = new AliArrayI;
79
80	for (Int_t i = 0; i<3; i++){
81	fTracks->Set(0);
82	fTrIndex->Set(0);
83	}
84	}
85
86	void AliSimDigits::AllocateTrack(Int_t length)
87	{
88	//
89	//construct empty buffer fElements and fTracks with size fNrows x fNcols x
90	//length
91	InvalidateTrack();
92	fNlevel = length;
93	fTracks->Set(fNcolsfNrowsfNlevel);
94	fTrIndex->Set(0);
95	fTrBufType =0;
96	}
97
98	Int_t AliSimDigits::GetTrackID(Int_t row, Int_t column, Int_t level)
99	{
100	//
101	//Get track ID
102	if (fTrBufType == 0) return GetTrackIDFast(row, column,level);
103	if (fTrBufType == 1) return GetTrackID1(row, column,level);
104	if (fTrBufType == 2) return GetTrackID2(row, column,level);
105	return 0;
106	}
107
108	void AliSimDigits::ExpandTrackBuffer()
109	{
110	//
111	//expand buffer to two dimensional array
112	if (fTrBufType<0) {
113	Error("ExpandBuffer", "buffer doesn't exist");
114	return;
115	}
116	if (fTrBufType==0) return; //buffer expanded
117	if (fTrBufType==1) {ExpandTrackBuffer1(); return;}
118	if (fTrBufType==2) ExpandTrackBuffer2();
119
120	}
121
122	void AliSimDigits::CompresTrackBuffer(Int_t bufType)
123	{
124	//
125	//compres buffer according buffertype algorithm
126	//
127	if (fTrBufType<0) {
128	Error("CompressBuffer", "buffer doesn't exist");
129	return;
130	}
131	if (fTrBufType == bufType) return;
132	//
133	if (fTrBufType>0) ExpandTrackBuffer();
134	if (fTrBufType !=0) {
135	Error("CompressBuffer", "buffer doesn't exist");
136	return;
137	}
138	//compress buffer of type 1
139
140	if (bufType==1) {CompresTrackBuffer1();return;}
141	if (bufType==2) CompresTrackBuffer2();
142
143	}
144
145	Int_t AliSimDigits::GetTrackID1(Int_t row, Int_t column, Int_t level)
146	{
147	//return track ID of digits - for buffer compresion 2
148	Int_t i,n1,n2;
149	i = level*fNcols+column;
150	if ( (i+1)>=fTrIndex->fN) n2 = fTracks->fN;
151	else
152	n2 = fTrIndex->At(i+1);
153	n1 = fTrIndex->At(i);
154	Int_t rownew = 0;
155	Int_t rowold=0;
156	Int_t ID;
157	for (i = n1;(i<n2);i++){
158	ID = 0;
159	Int_t num = fTracks->At(i);
160	if (num<0) {
161	rownew-=num;
162	rowold = rownew;
163	i++;
164	if (i<n2){
165	num = fTracks->At(i);
166	rownew+=num;
167	i++;
168	ID = fTracks->At(i);
169	}
170	}
171	else {
172	rowold = rownew;
173	rownew+=num;
174	i++;
175	ID = fTracks->At(i);
176	}
177	ID-=2;
178	if ( (row>=rowold) && (row<=rownew) ) return ID;
179	if (row < rownew ) return -2; //empty track
180	}
181	return -2;
182	}
183
184	void AliSimDigits::ExpandTrackBuffer1()
185	{
186	//
187	//expand track compressed according algorithm 1 (track ID comression independent to the digit compression)
188	// !!in expanded tracks we don't use fTrIndex array
189	//
190	fTrBufType = 0;
191	Int_t i,j;
192	Int_t all = fNrows*fNcols; //total number of digits
193	Int_t elems = all*fNlevel; //length of the buffer
194
195	AliArrayI * buf = new AliArrayI;
196	buf->Set(elems);
197	fTrIndex->Set(0);
198	//
199	Int_t level = 0;
200	Int_t col=0;
201	Int_t row = 0;
202	Int_t N=fTracks->fN;
203	//
204	for (i=0;i<N;i++){
205	//oposite signa means how many unwrited (under threshold) values
206	Int_t num = fTracks->At(i);
207	if (num<0) row-=num; //negative number mean number of zeroes (no tracks of gibven level no need to write to array)
208	else {
209	i++;
210	Int_t ID = fTracks->At(i);
211	for (j = 0; j<num; j++,row++) (buf)[levelall+col*fNrows+row]=ID;
212	}
213	if (row>=fNrows) {
214	row=0;
215	col++;
216	}
217	if (col>=fNcols) {
218	col=0;
219	level++;
220	}
221	}//end of loop over digits
222	delete fTracks;
223	fTracks = buf;
224	}
225
226	void AliSimDigits::CompresTrackBuffer1()
227	{
228	//
229	//comress track according algorithm 1 (track ID comression independent to the digit compression)
230	//
231	fTrBufType = 1;
232
233	AliArrayI * buf = new AliArrayI; //create new buffer
234	buf->Set(fNrowsfNcolsfNlevel); //lets have the nearly the "worst case"
235	AliArrayI * index = new AliArrayI;
236	index->Set(fNcols*fNlevel);
237
238	Int_t icurrent=-1; //current index
239	Int_t izero; //number of zero
240	Int_t inum; //number of digits with the same current track ID
241	Int_t lastID =0; //last track ID
242	for (Int_t lev =0; lev<fNlevel; lev++){ //loop over levels
243	for (Int_t col = 0; col<fNcols; col++){ //loop over columns
244	izero = 0;
245	inum = 0;
246	lastID = 0;
247	(index)[levfNcols+col]=icurrent+1;//set collumn pointer
248	Int_t ID; //current ID
249	for (Int_t row = 0; row< fNrows;row++){ //loop over rows
250	ID = GetTrackIDFast(row,col,lev);
251	if (ID <= 0) {
252	if ( inum> 0 ) { //if we have some tracks in buffer
253	icurrent++;
254	if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
255	(*buf)[icurrent] = inum;
256	icurrent++;
257	(*buf)[icurrent] = lastID;
258	inum = 0;
259	lastID = 0;
260	}
261	izero++;
262	}
263	else
264	if (ID != lastID)
265	if ( izero > 0 ) {
266	//if we have currently izero count of non tracks digits
267	icurrent++;
268	if (icurrent>=buf->fN) buf->Expand(icurrent*2);
269	(*buf)[icurrent]= -izero; //write how many under zero
270	inum++;
271	izero = 0;
272	lastID = ID;
273	}
274	else{
275	//if we change track ID from another track ID
276	icurrent++;
277	if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
278	(*buf)[icurrent] = inum;
279	icurrent++;
280	(*buf)[icurrent] = lastID;
281	lastID = ID;
282	inum = 1;
283	izero = 0;
284	}
285	else {
286	inum++;
287	}
288
289	}//end of loop over rows
290	if ( izero > 0 ) {
291	//if we have currently izero count of non tracks digits
292	icurrent++;
293	if (icurrent>=buf->fN) buf->Expand(icurrent*2);
294	(*buf)[icurrent]= -izero; //write how many under zero
295	}
296	if ( inum> 0 ) { //if we have some tracks in buffer
297	icurrent++;
298	if ((icurrent+1)>=buf->fN) buf->Expand(icurrent*2);
299	(*buf)[icurrent] = inum;
300	icurrent++;
301	(*buf)[icurrent] = ID;
302	}
303	}//end of loop over columns
304	}//end of loop over differnet track level
305	buf->Expand(icurrent+1);
306	delete fTracks;
307	fTracks = buf;
308	delete fTrIndex;
309	fTrIndex = index;
310	}
311
312
313
314	void AliSimDigits::ExpandTrackBuffer2()
315	{
316	//
317	//comress track according algorithm 2 (track ID comression according digit compression)
318	fTrBufType = 0;
319	}
320
321	void AliSimDigits::CompresTrackBuffer2()
322	{
323	//
324	//comress track according algorithm 2 (track ID comression according digit compression)
325	fTrBufType = 2;
326	}
327
328
329	Int_t AliSimDigits::GetTrackID2(Int_t row, Int_t column, Int_t level)
330	{
331	//returnb track ID of digits - for buffer compresion 2
332	return -2;
333	}
334
335
336
337	AliH2F * AliSimDigits::DrawTracks( const char *option,Int_t level,
338	Float_t x1, Float_t x2, Float_t y1, Float_t y2)
339	{
340	//
341	//draw digits in given array
342	//
343	//make digits histo
344	char ch[30];
345	sprintf(ch,"Track Segment_%d level %d ",GetID(),level );
346	if ( (fNrows<1)\|\| (fNcols<1)) {
347	return 0;
348	}
349	AliH2F * his = new AliH2F("Track histo",ch,fNrows,0,fNrows,fNcols,0,fNcols);
350	ExpandTrackBuffer();
351	//set histogram values
352	for (Int_t i = 0; i<fNrows;i++)
353	for (Int_t j = 0; j<fNcols;j++)
354	his->Fill(i,j,GetTrackIDFast(i,j,level));
355	if (x1>=0) {
356	AliH2F *h2fsub = his->GetSubrange2d(x1,x2,y1,y2);
357	delete his;
358	his=h2fsub;
359	}
360	if (his==0) return 0;
361	if (option!=0) his->Draw(option);
362	else his->Draw();
363	return his;
364	}
365
366	TClonesArray * AliSimDigits::GenerTPCClonesArray(TClonesArray * arr)
367	{
368	//
369	//generate TClonnesArray of digits
370	//
371	TClonesArray * digits;
372	if (arr==0) digits=new TClonesArray("AliTPCdigit",300);
373	else digits = arr;
374	Int_t index = digits->GetEntriesFast();
375	for (Int_t row =0; row<fNrows; row++)
376	for (Int_t col =0; col<fNcols; col++){
377	Int_t amp = GetDigit(row,col);
378	if (amp>GetThreshold()){
379	AliTPCdigit dig;
380	dig.fPad = col;
381	dig.fTime = row;
382	dig.fSignal= amp;
383	dig.fPadRow =fSegmentID;
384	dig.fSector =fSegmentID;
385	dig.fTracks[0]= GetTrackID(row,col,0);
386	dig.fTracks[1]= GetTrackID(row,col,1);
387	dig.fTracks[2]= GetTrackID(row,col,2);
388	TClonesArray &ldigits = *digits;
389	new(ldigits[index++]) AliTPCdigit(dig);
390	}
391	}
392	return digits;
393	}
394