[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCConfMapTrack.cxx

// @(#) $Id$
// Original: AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan 

//**************************************************************************
//* This file is property of and copyright by the ALICE HLT Project        * 
//* ALICE Experiment at CERN, All rights reserved.                         *
//*                                                                        *
//* Primary Authors: Anders Vestbo, maintained by                          *
//*                  Matthias Richter <Matthias.Richter@ift.uib.no>        *
//*                  for The ALICE HLT Project.                            *
//*                                                                        *
//* 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.                  *
//**************************************************************************

/** @file   AliHLTTPCConfMapTrack.cxx
    @author Anders Vestbo, maintained by Matthias Richter
    @date   
    @brief  Track class for conformal mapper
*/

#include "AliHLTTPCRootTypes.h"
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCVertex.h"
#include "AliHLTTPCConfMapPoint.h"
#include "AliHLTTPCConfMapFit.h"
#include "AliHLTTPCConfMapTrack.h"
#include "AliHLTTPCTransform.h"

#if __GNUC__ >= 3
using namespace std;
#endif

ClassImp(AliHLTTPCConfMapTrack)


AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack()
  :
  fCurrentHit(0),
  fLastHit(0),
  fFirstHit(0),
  fs11Xy(0),
  fs12Xy(0),
  fs22Xy(0),
  fg1Xy(0),
  fg2Xy(0),
  fs11Sz(0),
  fs12Sz(0),
  fs22Sz(0),
  fg1Sz(0),
  fg2Sz(0),
  fddXy(0),
  fa1Xy(0),
  fa2Xy(0),
  fddSz(0),
  fa1Sz(0),
  fa2Sz(0)
{
  //Constructor
  fChiSq[0] = 0.;
  fChiSq[1] = 0.;
}

AliHLTTPCConfMapTrack::~AliHLTTPCConfMapTrack()
{
  //deconstructor
}

void AliHLTTPCConfMapTrack::DeleteCandidate()
{
  //Deletes this track by resetting all its parameters. Does not delete
  //the object itself.

  AliHLTTPCConfMapPoint *curHit = (AliHLTTPCConfMapPoint*)fFirstHit;
  AliHLTTPCConfMapPoint *nextHit;
  
  while(curHit != 0)
    {
      nextHit = (AliHLTTPCConfMapPoint*)curHit->GetNextTrackHit();
      curHit->SetNextTrackHit(0);
      curHit = nextHit;
    }
  
  UInt_t *hit_numbers = GetHitNumbers();
  for(Int_t i=0; i<GetNHits(); i++)
    {
      //fHitNumbers[i] = 0;
      hit_numbers[i]=0;
    }
    
  SetRadius(0.);
  SetCenterX(0.);
  SetCenterY(0.);
  
  ComesFromMainVertex(false);

  SetNHits(0);
  SetCharge(0);
  fChiSq[0] = 0.;
  fChiSq[1] = 0.;
}


void AliHLTTPCConfMapTrack::SetProperties(Bool_t usage)
{
  //Set the hits to this track to 'usage'
  for(StartLoop(); LoopDone(); GetNextHit())
    {
      AliHLTTPCConfMapPoint *p = (AliHLTTPCConfMapPoint*)fCurrentHit;
      p->SetUsage(usage);
    }
  return;
}

void AliHLTTPCConfMapTrack::Reset()
{
  //Resets the fit parameters of this track.

  //xy-plane
  fs11Xy   = 0;
  fs12Xy   = 0;
  fs22Xy   = 0;
  fg1Xy    = 0;
  fg2Xy    = 0;
  fChiSq[0]  = 0.;
    
  //sz-plane
  fs11Sz = 0;
  fs12Sz = 0;
  fs22Sz = 0;
  fg1Sz  = 0;
  fg2Sz  = 0;
  fChiSq[1] = 0; 
  SetLength(0);
  SetNHits(0);
}

void AliHLTTPCConfMapTrack::UpdateParam(AliHLTTPCConfMapPoint *thisHit)
{
  //Function to update fit parameters of track
  //Also, it updates the hit pointers.
  

  //Increment the number of hits assigned to this track:

  //fNHits++;
  Int_t nhits = GetNHits();
  nhits++;
  SetNHits(nhits); //SetNHits(nhits++);

  //Set the hit pointers:
  //if(fNHits == 1)
  if(GetNHits()==1)  
    fFirstHit = thisHit;
  else
    ((AliHLTTPCConfMapPoint*)fLastHit)->SetNextTrackHit(thisHit);
  fLastHit = thisHit;

  
  fs11Xy = fs11Xy + thisHit->GetXYWeight() ;
  fs12Xy = fs12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ;
  fs22Xy = fs22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ;
  fg1Xy  = fg1Xy  + thisHit->GetXYWeight() * thisHit->GetYprime() ;
  fg2Xy  = fg2Xy  + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ;
    
  fddXy  = fs11Xy * fs22Xy - pow((fs12Xy),2) ;
  if ( fddXy != 0 ) 
    {
      fa1Xy  = ( fg1Xy * fs22Xy - fg2Xy * fs12Xy ) / fddXy ;
      fa2Xy  = ( fg2Xy * fs11Xy - fg1Xy * fs12Xy ) / fddXy ;
    }

  //     Now in the sz plane
  fs11Sz = fs11Sz + thisHit->GetZWeight() ;
  fs12Sz = fs12Sz + thisHit->GetZWeight() * thisHit->GetS() ;
  fs22Sz = fs22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ;
  fg1Sz  = fg1Sz  + thisHit->GetZWeight() * thisHit->GetZ() ;
  fg2Sz  = fg2Sz  + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ;
  
        
  fddSz  = fs11Sz * fs22Sz -  fs12Sz * fs12Sz ;
  if ( fddSz != 0 ) {
    fa1Sz  = ( fg1Sz * fs22Sz - fg2Sz * fs12Sz ) / fddSz ;
    fa2Sz  = ( fg2Sz * fs11Sz - fg1Sz * fs12Sz ) / fddSz ;
  }
}


void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
{
    //Fill track variables with or without fit.
    
    // for straight line fit
    if (AliHLTTPCTransform::GetBFieldValue() == 0.0 ){

	SetRadius(0.);	
	SetPt(0.);
	
	//go for fit of straight line in real space
	AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
    /* Matthias 13.12.2006
     * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
     * and has always been kTRUE.
     * In order to remove the AliHLTTPC class (which is the old steering class for
     * HLT (TPC) tracking) from the compilation, this function can not be activated
     * again. We have to think about a more elegant way to specify the parameters
     * anyway. 
	ComesFromMainVertex(AliHLTTPC::DoVertexFit());
     */
	ComesFromMainVertex(kTRUE);
	fit->FitStraightLine();
	    
	AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
	SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
	
	UpdateToFirstPoint();
	
	delete fit;
	
    }
    // for helix fit
    else { 
      //fRadius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
      Double_t radius = sqrt(fa2Xy*fa2Xy+1)/(2*fabs(fa1Xy));
      SetRadius(radius);
      
      //fPt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * fRadius);
      Double_t pt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * GetRadius());
      SetPt(pt);
      //Set Error here?????
      
      if(GetPt() > max_Dca) //go for fit of helix in real space
	{
	  AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
    /* Matthias 13.12.2006
     * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
     * and has always been kTRUE.
     * In order to remove the AliHLTTPC class (which is the old steering class for
     * HLT (TPC) tracking) from the compilation, this function can not be activated
     * again. We have to think about a more elegant way to specify the parameters
     * anyway. 
	    ComesFromMainVertex(AliHLTTPC::DoVertexFit());
     */
	  ComesFromMainVertex(kTRUE);
	  fit->FitHelix();
	  
	  //AliHLTTPCConfMapPoint *lHit = (AliHLTTPCConfMapPoint*)fLastHit;
	  AliHLTTPCConfMapPoint *fHit = (AliHLTTPCConfMapPoint*)fFirstHit;
	  SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
	  
	  UpdateToFirstPoint();
	  
	  delete fit;
	}
      else if(GetPt() == 0) 
	{
	  LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
	    "Found track with Pt=0!!!"<<ENDLOG;
	}
      else
	{
	  LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
	    "Track with pt<max_Dca :"<<GetPt()<<ENDLOG;
	}
    }
}

Int_t AliHLTTPCConfMapTrack::GetMCLabel()
{
  //For evaluation study.
  //Returns the MCtrackID of the belonging clusters.
  //If MCLabel < 0, means that track is fake.

  return 0;
  /*
  Int_t num_of_clusters = GetNumberOfPoints();
  S *s=new S[num_of_clusters];
  Int_t i;
  for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0;
  
  Int_t lab=123456789;
  for (i=0; i<num_of_clusters; i++) {
    AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
    lab=fabs(c->fMCTrackID[0]);
    Int_t j;
    for (j=0; j<num_of_clusters; j++)
      if (s[j].lab==lab || s[j].max==0) break;
    s[j].lab=lab;
    s[j].max++;
  }
  
  Int_t max=0;
  for (i=0; i<num_of_clusters; i++) 
    if (s[i].max>max) {max=s[i].max; lab=s[i].lab;}
    
  delete[] s;
  
  for (i=0; i<num_of_clusters; i++) {
    AliHLTTPCConfMapPoint *c=(AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(i);
    if (fabs(c->fMCTrackID[1]) == lab ||
	fabs(c->fMCTrackID[2]) == lab ) max++;
  }
  
  //check if more than 10% of the clusters are incorrectly assigned (fake track):
  
  if (1.-Float_t(max)/num_of_clusters > 0.10) 
    {
      return -lab;
    }
  Int_t tail=Int_t(0.08*174);
  if (num_of_clusters < tail) return lab;
  
  max=0;
  for (i=1; i<=tail; i++) {
    AliHLTTPCConfMapPoint *c = (AliHLTTPCConfMapPoint*)fPoints->UncheckedAt(num_of_clusters-i);
    if (lab == fabs(c->fMCTrackID[0]) ||
	lab == fabs(c->fMCTrackID[1]) ||
	lab == fabs(c->fMCTrackID[2])) max++;
  }
  if (max < Int_t(0.5*tail)) 
    {
      //printf("Wrong innermost clusters\n");
      return -lab;
    }
  return lab;
  */
}
Commit	Line	Data
a6c02c85	1	// @(#) $Id$
4aa41877	2	// Original: AliHLTConfMapTrack.cxx,v 1.16 2005/06/14 10:55:21 cvetan
a6c02c85	3
297174de	4	//**************************************************************************
	5	//* This file is property of and copyright by the ALICE HLT Project *
	6	//* ALICE Experiment at CERN, All rights reserved. *
	7	//* *
	8	//* Primary Authors: Anders Vestbo, maintained by *
	9	//* Matthias Richter <Matthias.Richter@ift.uib.no> *
	10	//* for The ALICE HLT Project. *
	11	//* *
	12	//* Permission to use, copy, modify and distribute this software and its *
	13	//* documentation strictly for non-commercial purposes is hereby granted *
	14	//* without fee, provided that the above copyright notice appears in all *
	15	//* copies and that both the copyright notice and this permission notice *
	16	//* appear in the supporting documentation. The authors make no claims *
	17	//* about the suitability of this software for any purpose. It is *
	18	//* provided "as is" without express or implied warranty. *
	19	//**************************************************************************
2a083ac4	20
	21	/** @file AliHLTTPCConfMapTrack.cxx
	22	@author Anders Vestbo, maintained by Matthias Richter
	23	@date
	24	@brief Track class for conformal mapper
	25	*/
a6c02c85	26
a6c02c85	27	#include "AliHLTTPCRootTypes.h"
	28	#include "AliHLTTPCLogging.h"
	29	#include "AliHLTTPCVertex.h"
	30	#include "AliHLTTPCConfMapPoint.h"
	31	#include "AliHLTTPCConfMapFit.h"
	32	#include "AliHLTTPCConfMapTrack.h"
	33	#include "AliHLTTPCTransform.h"
a6c02c85	34
a6c02c85	35	#if __GNUC__ >= 3
	36	using namespace std;
	37	#endif
	38
	39	ClassImp(AliHLTTPCConfMapTrack)
	40
	41
	42	AliHLTTPCConfMapTrack::AliHLTTPCConfMapTrack()
e419b223	43	:
	44	fCurrentHit(0),
	45	fLastHit(0),
	46	fFirstHit(0),
	47	fs11Xy(0),
	48	fs12Xy(0),
	49	fs22Xy(0),
	50	fg1Xy(0),
	51	fg2Xy(0),
	52	fs11Sz(0),
	53	fs12Sz(0),
	54	fs22Sz(0),
	55	fg1Sz(0),
	56	fg2Sz(0),
	57	fddXy(0),
	58	fa1Xy(0),
	59	fa2Xy(0),
	60	fddSz(0),
	61	fa1Sz(0),
	62	fa2Sz(0)
a6c02c85	63	{
	64	//Constructor
	65	fChiSq[0] = 0.;
	66	fChiSq[1] = 0.;
	67	}
	68
	69	AliHLTTPCConfMapTrack::~AliHLTTPCConfMapTrack()
	70	{
	71	//deconstructor
	72	}
	73
	74	void AliHLTTPCConfMapTrack::DeleteCandidate()
	75	{
	76	//Deletes this track by resetting all its parameters. Does not delete
	77	//the object itself.
	78
	79	AliHLTTPCConfMapPoint curHit = (AliHLTTPCConfMapPoint)fFirstHit;
	80	AliHLTTPCConfMapPoint *nextHit;
	81
	82	while(curHit != 0)
	83	{
	84	nextHit = (AliHLTTPCConfMapPoint*)curHit->GetNextTrackHit();
	85	curHit->SetNextTrackHit(0);
	86	curHit = nextHit;
	87	}
	88
	89	UInt_t *hit_numbers = GetHitNumbers();
	90	for(Int_t i=0; i<GetNHits(); i++)
	91	{
	92	//fHitNumbers[i] = 0;
	93	hit_numbers[i]=0;
	94	}
	95
	96	SetRadius(0.);
	97	SetCenterX(0.);
	98	SetCenterY(0.);
	99
	100	ComesFromMainVertex(false);
	101
	102	SetNHits(0);
	103	SetCharge(0);
	104	fChiSq[0] = 0.;
	105	fChiSq[1] = 0.;
	106	}
	107
	108
	109	void AliHLTTPCConfMapTrack::SetProperties(Bool_t usage)
	110	{
	111	//Set the hits to this track to 'usage'
	112	for(StartLoop(); LoopDone(); GetNextHit())
	113	{
	114	AliHLTTPCConfMapPoint p = (AliHLTTPCConfMapPoint)fCurrentHit;
	115	p->SetUsage(usage);
	116	}
	117	return;
	118	}
	119
	120	void AliHLTTPCConfMapTrack::Reset()
	121	{
	122	//Resets the fit parameters of this track.
	123
	124	//xy-plane
	125	fs11Xy = 0;
	126	fs12Xy = 0;
127	fs22Xy = 0;
128	fg1Xy = 0;
129	fg2Xy = 0;
130	fChiSq[0] = 0.;
131
132	//sz-plane
133	fs11Sz = 0;
134	fs12Sz = 0;
135	fs22Sz = 0;
136	fg1Sz = 0;
137	fg2Sz = 0;
138	fChiSq[1] = 0;
139	SetLength(0);
140	SetNHits(0);
141	}
142
143	void AliHLTTPCConfMapTrack::UpdateParam(AliHLTTPCConfMapPoint *thisHit)
144	{
145	//Function to update fit parameters of track
146	//Also, it updates the hit pointers.
147
148
149	//Increment the number of hits assigned to this track:
150
151	//fNHits++;
152	Int_t nhits = GetNHits();
153	nhits++;
154	SetNHits(nhits); //SetNHits(nhits++);
155
156	//Set the hit pointers:
157	//if(fNHits == 1)
158	if(GetNHits()==1)
159	fFirstHit = thisHit;
160	else
161	((AliHLTTPCConfMapPoint*)fLastHit)->SetNextTrackHit(thisHit);
162	fLastHit = thisHit;
163
164
165	fs11Xy = fs11Xy + thisHit->GetXYWeight() ;
166	fs12Xy = fs12Xy + thisHit->GetXYWeight() * thisHit->GetXprime() ;
167	fs22Xy = fs22Xy + thisHit->GetXYWeight() * pow((thisHit->GetXprime()),2) ;
168	fg1Xy = fg1Xy + thisHit->GetXYWeight() * thisHit->GetYprime() ;
169	fg2Xy = fg2Xy + thisHit->GetXYWeight() * thisHit->GetXprime() * thisHit->GetYprime() ;
170
171	fddXy = fs11Xy * fs22Xy - pow((fs12Xy),2) ;
172	if ( fddXy != 0 )
173	{
174	fa1Xy = ( fg1Xy * fs22Xy - fg2Xy * fs12Xy ) / fddXy ;
175	fa2Xy = ( fg2Xy * fs11Xy - fg1Xy * fs12Xy ) / fddXy ;
176	}
177
178	// Now in the sz plane
179	fs11Sz = fs11Sz + thisHit->GetZWeight() ;
180	fs12Sz = fs12Sz + thisHit->GetZWeight() * thisHit->GetS() ;
181	fs22Sz = fs22Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetS() ;
182	fg1Sz = fg1Sz + thisHit->GetZWeight() * thisHit->GetZ() ;
183	fg2Sz = fg2Sz + thisHit->GetZWeight() * thisHit->GetS() * thisHit->GetZ() ;
184
185
186	fddSz = fs11Sz * fs22Sz - fs12Sz * fs12Sz ;
187	if ( fddSz != 0 ) {
188	fa1Sz = ( fg1Sz * fs22Sz - fg2Sz * fs12Sz ) / fddSz ;
189	fa2Sz = ( fg2Sz * fs11Sz - fg1Sz * fs12Sz ) / fddSz ;
190	}
191	}
192
193
194	void AliHLTTPCConfMapTrack::Fill(AliHLTTPCVertex *vertex,Double_t max_Dca)
195	{
db16520a	196	//Fill track variables with or without fit.
db16520a	197
db16520a	198	// for straight line fit
	199	if (AliHLTTPCTransform::GetBFieldValue() == 0.0 ){
	200
	201	SetRadius(0.);
	202	SetPt(0.);
	203
	204	//go for fit of straight line in real space
	205	AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
a7c32962	206	/* Matthias 13.12.2006
	207	* the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
	208	* and has always been kTRUE.
	209	* In order to remove the AliHLTTPC class (which is the old steering class for
	210	* HLT (TPC) tracking) from the compilation, this function can not be activated
	211	* again. We have to think about a more elegant way to specify the parameters
	212	* anyway.
db16520a	213	ComesFromMainVertex(AliHLTTPC::DoVertexFit());
a7c32962	214	*/
a7c32962	215	ComesFromMainVertex(kTRUE);
db16520a	216	fit->FitStraightLine();
	217
	218	AliHLTTPCConfMapPoint fHit = (AliHLTTPCConfMapPoint)fFirstHit;
	219	SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
	220
	221	UpdateToFirstPoint();
	222
	223	delete fit;
	224
a6c02c85	225	}
db16520a	226	// for helix fit
db16520a	227	else {
437e8e54	228	//fRadius = sqrt(fa2Xyfa2Xy+1)/(2fabs(fa1Xy));
	229	Double_t radius = sqrt(fa2Xyfa2Xy+1)/(2fabs(fa1Xy));
	230	SetRadius(radius);
	231
	232	//fPt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * fRadius);
	233	Double_t pt = (Double_t)(AliHLTTPCTransform::GetBFieldValue() * GetRadius());
	234	SetPt(pt);
31f11c63	235	//Set Error here?????
437e8e54	236
437e8e54	237	if(GetPt() > max_Dca) //go for fit of helix in real space
db16520a	238	{
437e8e54	239	AliHLTTPCConfMapFit *fit = new AliHLTTPCConfMapFit(this,vertex);
a7c32962	240	/* Matthias 13.12.2006
	241	* the global variable AliHLTTPCS::fgDoVertexFit has never been used so far
	242	* and has always been kTRUE.
	243	* In order to remove the AliHLTTPC class (which is the old steering class for
	244	* HLT (TPC) tracking) from the compilation, this function can not be activated
	245	* again. We have to think about a more elegant way to specify the parameters
	246	* anyway.
db16520a	247	ComesFromMainVertex(AliHLTTPC::DoVertexFit());
a7c32962	248	*/
437e8e54	249	ComesFromMainVertex(kTRUE);
	250	fit->FitHelix();
	251
	252	//AliHLTTPCConfMapPoint lHit = (AliHLTTPCConfMapPoint)fLastHit;
	253	AliHLTTPCConfMapPoint fHit = (AliHLTTPCConfMapPoint)fFirstHit;
	254	SetLastPoint(fHit->GetX(),fHit->GetY(),fHit->GetZ());
	255
	256	UpdateToFirstPoint();
	257
	258	delete fit;
db16520a	259	}
437e8e54	260	else if(GetPt() == 0)
fc455fba	261	{
437e8e54	262	LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
437e8e54	263	"Found track with Pt=0!!!"<<ENDLOG;
fc455fba	264	}
437e8e54	265	else
db16520a	266	{
437e8e54	267	LOG(AliHLTTPCLog::kError,"AliHLTTPCConfMapTrack::Fill","Tracks")<<AliHLTTPCLog::kDec<<
437e8e54	268	"Track with pt<max_Dca :"<<GetPt()<<ENDLOG;
db16520a	269	}
a6c02c85	270	}
	271	}
	272
	273	Int_t AliHLTTPCConfMapTrack::GetMCLabel()
	274	{
	275	//For evaluation study.
	276	//Returns the MCtrackID of the belonging clusters.
	277	//If MCLabel < 0, means that track is fake.
	278
	279	return 0;
	280	/*
	281	Int_t num_of_clusters = GetNumberOfPoints();
	282	S *s=new S[num_of_clusters];
	283	Int_t i;
	284	for (i=0; i<num_of_clusters; i++) s[i].lab=s[i].max=0;
	285
	286	Int_t lab=123456789;
	287	for (i=0; i<num_of_clusters; i++) {
	288	AliHLTTPCConfMapPoint c=(AliHLTTPCConfMapPoint)fPoints->UncheckedAt(i);
	289	lab=fabs(c->fMCTrackID[0]);
	290	Int_t j;
	291	for (j=0; j<num_of_clusters; j++)
	292	if (s[j].lab==lab \|\| s[j].max==0) break;
	293	s[j].lab=lab;
	294	s[j].max++;
	295	}
	296
	297	Int_t max=0;
	298	for (i=0; i<num_of_clusters; i++)
	299	if (s[i].max>max) {max=s[i].max; lab=s[i].lab;}
	300
	301	delete[] s;
	302
	303	for (i=0; i<num_of_clusters; i++) {
	304	AliHLTTPCConfMapPoint c=(AliHLTTPCConfMapPoint)fPoints->UncheckedAt(i);
	305	if (fabs(c->fMCTrackID[1]) == lab \|\|
	306	fabs(c->fMCTrackID[2]) == lab ) max++;
	307	}
	308
	309	//check if more than 10% of the clusters are incorrectly assigned (fake track):
	310
	311	if (1.-Float_t(max)/num_of_clusters > 0.10)
	312	{
	313	return -lab;
	314	}
	315	Int_t tail=Int_t(0.08*174);
	316	if (num_of_clusters < tail) return lab;
	317
	318	max=0;
	319	for (i=1; i<=tail; i++) {
	320	AliHLTTPCConfMapPoint c = (AliHLTTPCConfMapPoint)fPoints->UncheckedAt(num_of_clusters-i);
	321	if (lab == fabs(c->fMCTrackID[0]) \|\|
	322	lab == fabs(c->fMCTrackID[1]) \|\|
	323	lab == fabs(c->fMCTrackID[2])) max++;
	324	}
	325	if (max < Int_t(0.5*tail))
	326	{
	327	//printf("Wrong innermost clusters\n");
	328	return -lab;
	329	}
	330	return lab;
	331	*/
	332	}
	333