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

// @(#) $Id$
// Original: AliHLTConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov 

/**************************************************************************
 * 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   AliHLTTPCConfMapPoint.cxx
    @author Anders Vestbo, maintained by Matthias Richter
    @date   
    @brief  Hit class for conformal mapper
*/

#include <cassert>
#include "AliHLTTPCLogging.h"
#include "AliHLTTPCConfMapPoint.h"
#include "AliHLTTPCSpacePointData.h"
#include "AliHLTTPCVertex.h"
#include "AliHLTTPCConfMapTrack.h"

/**
<pre>
//_____________________________________________________________
// AliHLTTPCConfMapPoint
//
// Hit class for conformal mapper
</pre>
*/

/** ROOT macro for the implementation of ROOT specific class methods */
ClassImp(AliHLTTPCConfMapPoint);

Bool_t AliHLTTPCConfMapPoint::fgDontMap=kFALSE;

AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint()
  :
  fHitNumber(-1),
  fTrackNumber(0),
  fNextHitNumber(0),
  fUsed(kFALSE),
  fPadrow(0),
  fSector(0),
  fx(0),
  fy(0),
  fz(0),
  fxerr(0),
  fyerr(0),
  fzerr(0),
  fWxy(0),
  fWz(0),
  fs(0),
  fXt(0),
  fYt(0),
  fZt(0),
  fXterr(0),
  fYterr(0),
  fZterr(0),
  fXprime(0),
  fYprime(0),
  fXprimeerr(0),
  fYprimeerr(0),
  fXv(0),
  fYv(0),
  fZv(0),
  fXverr(0),
  fYverr(0),
  fZverr(0),
  fPhi(0),
  fEta(0),
  fNextVolumeHit(NULL),
  fNextRowHit(NULL),
  fNextTrackHit(NULL),
  fPhiIndex(0),
  fEtaIndex(0),
  fXYChi2(0),
  fSZChi2(0)
{
  //Constructor
  fMCTrackID[0]=-1;
  fMCTrackID[1]=-1;
  fMCTrackID[2]=-1;
}

AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint& src)
  :
  fHitNumber(src.fHitNumber),
  fTrackNumber(src.fTrackNumber),
  fNextHitNumber(src.fNextHitNumber),
  fUsed(src.fUsed),
  fPadrow(src.fPadrow),
  fSector(src.fSector),
  fx(src.fx),
  fy(src.fy),
  fz(src.fz),
  fxerr(src.fxerr),
  fyerr(src.fyerr),
  fzerr(src.fzerr),
  fWxy(src.fWxy),
  fWz(src.fWz),
  fs(src.fs),
  fXt(src.fXt),
  fYt(src.fYt),
  fZt(src.fZt),
  fXterr(src.fXterr),
  fYterr(src.fYterr),
  fZterr(src.fZterr),
  fXprime(src.fXprime),
  fYprime(src.fYprime),
  fXprimeerr(src.fXprimeerr),
  fYprimeerr(src.fYprimeerr),
  fXv(src.fXv),
  fYv(src.fYv),
  fZv(src.fZv),
  fXverr(src.fXverr),
  fYverr(src.fYverr),
  fZverr(src.fZverr),
  fPhi(src.fPhi),
  fEta(src.fEta),
  fNextVolumeHit(src.fNextVolumeHit),
  fNextRowHit(src.fNextRowHit),
  fNextTrackHit(src.fNextTrackHit),
  fPhiIndex(src.fPhiIndex),
  fEtaIndex(src.fEtaIndex),
  fXYChi2(src.fXYChi2),
  fSZChi2(src.fSZChi2)
{
  //Copy Constructor
  fMCTrackID[0]=src.fMCTrackID[0];
  fMCTrackID[1]=src.fMCTrackID[1];
  fMCTrackID[2]=src.fMCTrackID[2];
}

AliHLTTPCConfMapPoint& AliHLTTPCConfMapPoint::operator=(const AliHLTTPCConfMapPoint& src)
{
  fHitNumber=src.fHitNumber;
  fTrackNumber=src.fTrackNumber;
  fNextHitNumber=src.fNextHitNumber;
  fUsed=src.fUsed;
  fPadrow=src.fPadrow;
  fSector=src.fSector;
  fx=src.fx;
  fy=src.fy;
  fz=src.fz;
  fxerr=src.fxerr;
  fyerr=src.fyerr;
  fzerr=src.fzerr;
  fWxy=src.fWxy;
  fWz=src.fWz;
  fs=src.fs;
  fXt=src.fXt;
  fYt=src.fYt;
  fZt=src.fZt;
  fXterr=src.fXterr;
  fYterr=src.fYterr;
  fZterr=src.fZterr;
  fXprime=src.fXprime;
  fYprime=src.fYprime;
  fXprimeerr=src.fXprimeerr;
  fYprimeerr=src.fYprimeerr;
  fXv=src.fXv;
  fYv=src.fYv;
  fZv=src.fZv;
  fXverr=src.fXverr;
  fYverr=src.fYverr;
  fZverr=src.fZverr;
  fPhi=src.fPhi;
  fEta=src.fEta;
  fNextVolumeHit=src.fNextVolumeHit;
  fNextRowHit=src.fNextRowHit;
  fNextTrackHit=src.fNextTrackHit;
  fPhiIndex=src.fPhiIndex;
  fEtaIndex=src.fEtaIndex;
  fXYChi2=src.fXYChi2;
  fSZChi2=src.fSZChi2;
  fMCTrackID[0]=src.fMCTrackID[0];
  fMCTrackID[1]=src.fMCTrackID[1];
  fMCTrackID[2]=src.fMCTrackID[2];

  return *this;
}

AliHLTTPCConfMapPoint::~AliHLTTPCConfMapPoint()
{
  // Destructor.
}

Bool_t AliHLTTPCConfMapPoint::Read(const AliHLTTPCSpacePointData& hit)
{
  //read the hits
  SetHitNumber(hit.fID);
  SetPadRow(hit.fPadRow);  
  SetSector(hit.GetSlice());
  SetX(hit.fX);
  SetY(hit.fY);
  SetZ(hit.fZ);
  SetXerr(sqrt(hit.fSigmaY2));
  SetYerr(sqrt(hit.fSigmaY2));
  SetZerr(sqrt(hit.fSigmaZ2));
  return kTRUE;
}

void AliHLTTPCConfMapPoint::Reset()
{
  //Reset this point.
  SetUsage(kFALSE);
  SetS(0);
  fNextRowHit = NULL;
  fNextVolumeHit=NULL;
  fNextTrackHit=NULL;
}

void AliHLTTPCConfMapPoint::Setup(AliHLTTPCVertex *vertex)
{
  //Setup. Sets the vertex, conformal coordinates, 
  //and phi and eta of each hit.
  
  SetIntPoint(vertex->GetX(),    vertex->GetY(),    vertex->GetZ(),
              vertex->GetXErr(), vertex->GetYErr(), vertex->GetZErr());
  SetShiftedCoord();
  SetConfCoord();
  // The angles are set properly if they are set after 
  // the interaction point and the shifted coordinates
  SetAngles();
  //SetDist(0., 0.);
  return;
}

void AliHLTTPCConfMapPoint::SetIntPoint(Double_t inx, Double_t iny, Double_t inz,
			            Double_t inxerr, Double_t inyerr, Double_t inzerr)
{
  // Defines a new interaction point. This point is needed to calculate
  // the conformal coordinates.

  SetXt(inx);
  SetYt(iny);
  SetZt(inz);
  SetXterr(inxerr);
  SetYterr(inyerr);
  SetZterr(inzerr);

  return;
}

void AliHLTTPCConfMapPoint::SetAllCoord(const AliHLTTPCConfMapPoint *precedinghit)
{
  // Sets the interaction point, the shifted coordinates, and the conformal mapping coordinates.
  // These values are calculated from the interaction point of the given cluster which should be a
  // already found cluster on the same track.

  if (this == precedinghit) {
    SetIntPoint(precedinghit->GetX(),    precedinghit->GetY(),    precedinghit->GetZ(),
                precedinghit->GetXerr(), precedinghit->GetYerr(), precedinghit->GetZerr());
  }

  else {
    SetIntPoint(precedinghit->GetXt(),    precedinghit->GetYt(),    precedinghit->GetZt(),
                precedinghit->GetXterr(), precedinghit->GetYterr(), precedinghit->GetZterr());
  }

  SetShiftedCoord();
  SetConfCoord();

  return;
}

void AliHLTTPCConfMapPoint::SetShiftedCoord()
{
  // Sets the coordinates with resepct to the given vertex point

  SetXv(GetX() - fXt);
  SetYv(GetY() - fYt);
  SetZv(GetZ() - fZt);
  /*
  SetXverr(TMath::Sqrt(GetXerr()*GetXerr() + fXterr*fXterr));
  SetYverr(TMath::Sqrt(GetYerr()*GetYerr() + fYterr*fYterr));
  SetZverr(TMath::Sqrt(GetZerr()*GetZerr() + fZterr*fZterr));
  */
  return;
}

void AliHLTTPCConfMapPoint::SetConfCoord()
{
  // Calculates the conformal coordinates of one cluster.
  // If the option "vertex_constraint" applies the interaction point is
  // assumed to be at (0, 0, 0). Otherwise the function will use the
  // interaction point specified by fXt and fYt.

  if(fgDontMap){
    fXprime = fx;
    fYprime = fy;
    fWxy = 0;
    fs = 0; //track trajectory
    fWz = 0;
    return;
  }

  Double_t r2;
  Double_t xyErrorScale = 1;
  Double_t szErrorScale = 1;

  if ((r2 = fXv*fXv + fYv*fYv)) 
    {
      fXprime =  fXv / r2;
      fYprime = -fYv / r2;
      
      //set weights:
      fWxy = r2*r2 / ((xyErrorScale*xyErrorScale)*((fxerr*fxerr)+(fyerr*fyerr)));
      fs = 0; //track trajectory
      fWz = (Double_t)(1./(szErrorScale*fzerr*fzerr));
    } else {
    fXprime    = 0.;
    fYprime    = 0.;
    fXprimeerr = 0.;
    fYprimeerr = 0.;
    fWxy = 0;
    fWz = 0;
    fs = 0;
  }

  return;
}

void AliHLTTPCConfMapPoint::SetAngles()
{
  // Calculates the angle phi and the pseudorapidity eta for each cluster.
  /*
  Double_t r = TMath::Sqrt(x*x + y*y);

  fPhi = TMath::ATan2(y,x);
  if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
  fEta = 3.*z/(TMath::Abs(z)+2.*r);
  return;
  */
  //  Double_t r3dim = TMath::Sqrt(fXv*fXv + fYv*fYv + fZv*fZv);
  Double_t r3dim = sqrt(fXv*fXv + fYv*fYv + fZv*fZv);
  //Double_t r2dim = TMath::Sqrt(fXv*fXv + fYv*fYv);

  /*if (r2dim == 0.) {
  // If r2dim == 0 the pseudorapidity eta cannot be calculated (division by zero)!
  // This can only happen if the point is lying on the z-axis and this should never be possible.
    cerr << "The pseudorapidity eta cannot be calculated (division by zero)! Set to 1.e-10." << endl;
    r2dim = 1.e-10;
  }

  if (fXv == 0.) {
    fPhi = (fYv > 0.) ? TMath::Pi() / 2. : - TMath::Pi() / 2.;
  }

  else {
    fPhi = (fXv > 0.) ? TMath::ASin(fYv/r2dim) : TMath::Pi() - TMath::ASin(fYv/r2dim);
  }

  if (fPhi < 0.) {
    fPhi += 2. * TMath::Pi();
  }
  */
  //fPhi = TMath::ATan2(y,x);
  fPhi = atan2(fy,fx);
  //if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
  
  //fEta = 0.5 * TMath::Log((r3dim + fZv)/(r3dim - fZv));
  fEta = 0.5 * log((r3dim + fZv)/(r3dim - fZv));
  return;
}

/*
AliHLTTPCConfMapTrack *AliHLTTPCConfMapPoint::GetTrack(TClonesArray *tracks) const
{
  // Returns the pointer to the track to which this hit belongs.
  
  return (AliHLTTPCConfMapTrack*)tracks->At(this->GetTrackNumber());
}
*/
Commit	Line	Data
a6c02c85	1	// @(#) $Id$
4aa41877	2	// Original: AliHLTConfMapPoint.cxx,v 1.10 2005/06/23 17:46:55 hristov
a6c02c85	3
2a083ac4	4	/**************************************************************************
9be2600f	5	* This file is property of and copyright by the ALICE HLT Project *
9be2600f	6	* ALICE Experiment at CERN, All rights reserved. *
2a083ac4	7	* *
9be2600f	8	* Primary Authors: Anders Vestbo, maintained by *
	9	* Matthias Richter <Matthias.Richter@ift.uib.no> *
	10	* for The ALICE HLT Project. *
2a083ac4	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	**************************************************************************/
	20
	21	/** @file AliHLTTPCConfMapPoint.cxx
	22	@author Anders Vestbo, maintained by Matthias Richter
	23	@date
	24	@brief Hit class for conformal mapper
	25	*/
a6c02c85	26
055fed30	27	#include <cassert>
a6c02c85	28	#include "AliHLTTPCLogging.h"
	29	#include "AliHLTTPCConfMapPoint.h"
	30	#include "AliHLTTPCSpacePointData.h"
	31	#include "AliHLTTPCVertex.h"
	32	#include "AliHLTTPCConfMapTrack.h"
	33
	34	/**
	35	<pre>
	36	//_____________________________________________________________
	37	// AliHLTTPCConfMapPoint
	38	//
	39	// Hit class for conformal mapper
86268ca8	40	</pre>
a6c02c85	41	*/
a6c02c85	42
86268ca8	43	/** ROOT macro for the implementation of ROOT specific class methods */
86268ca8	44	ClassImp(AliHLTTPCConfMapPoint);
a6c02c85	45
	46	Bool_t AliHLTTPCConfMapPoint::fgDontMap=kFALSE;
	47
	48	AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint()
e419b223	49	:
	50	fHitNumber(-1),
	51	fTrackNumber(0),
	52	fNextHitNumber(0),
055fed30	53	fUsed(kFALSE),
e419b223	54	fPadrow(0),
	55	fSector(0),
	56	fx(0),
	57	fy(0),
	58	fz(0),
	59	fxerr(0),
	60	fyerr(0),
	61	fzerr(0),
	62	fWxy(0),
	63	fWz(0),
	64	fs(0),
	65	fXt(0),
	66	fYt(0),
	67	fZt(0),
	68	fXterr(0),
	69	fYterr(0),
	70	fZterr(0),
	71	fXprime(0),
	72	fYprime(0),
	73	fXprimeerr(0),
	74	fYprimeerr(0),
	75	fXv(0),
	76	fYv(0),
	77	fZv(0),
	78	fXverr(0),
	79	fYverr(0),
	80	fZverr(0),
	81	fPhi(0),
	82	fEta(0),
055fed30	83	fNextVolumeHit(NULL),
	84	fNextRowHit(NULL),
	85	fNextTrackHit(NULL),
e419b223	86	fPhiIndex(0),
	87	fEtaIndex(0),
	88	fXYChi2(0),
	89	fSZChi2(0)
a6c02c85	90	{
a6c02c85	91	//Constructor
055fed30	92	fMCTrackID[0]=-1;
	93	fMCTrackID[1]=-1;
	94	fMCTrackID[2]=-1;
	95	}
	96
	97	AliHLTTPCConfMapPoint::AliHLTTPCConfMapPoint(const AliHLTTPCConfMapPoint& src)
	98	:
	99	fHitNumber(src.fHitNumber),
	100	fTrackNumber(src.fTrackNumber),
	101	fNextHitNumber(src.fNextHitNumber),
	102	fUsed(src.fUsed),
	103	fPadrow(src.fPadrow),
	104	fSector(src.fSector),
	105	fx(src.fx),
	106	fy(src.fy),
	107	fz(src.fz),
	108	fxerr(src.fxerr),
	109	fyerr(src.fyerr),
	110	fzerr(src.fzerr),
	111	fWxy(src.fWxy),
	112	fWz(src.fWz),
	113	fs(src.fs),
	114	fXt(src.fXt),
	115	fYt(src.fYt),
	116	fZt(src.fZt),
	117	fXterr(src.fXterr),
	118	fYterr(src.fYterr),
	119	fZterr(src.fZterr),
	120	fXprime(src.fXprime),
	121	fYprime(src.fYprime),
	122	fXprimeerr(src.fXprimeerr),
	123	fYprimeerr(src.fYprimeerr),
	124	fXv(src.fXv),
	125	fYv(src.fYv),
	126	fZv(src.fZv),
	127	fXverr(src.fXverr),
	128	fYverr(src.fYverr),
	129	fZverr(src.fZverr),
	130	fPhi(src.fPhi),
	131	fEta(src.fEta),
	132	fNextVolumeHit(src.fNextVolumeHit),
	133	fNextRowHit(src.fNextRowHit),
	134	fNextTrackHit(src.fNextTrackHit),
	135	fPhiIndex(src.fPhiIndex),
	136	fEtaIndex(src.fEtaIndex),
	137	fXYChi2(src.fXYChi2),
	138	fSZChi2(src.fSZChi2)
	139	{
	140	//Copy Constructor
	141	fMCTrackID[0]=src.fMCTrackID[0];
	142	fMCTrackID[1]=src.fMCTrackID[1];
	143	fMCTrackID[2]=src.fMCTrackID[2];
	144	}
	145
	146	AliHLTTPCConfMapPoint& AliHLTTPCConfMapPoint::operator=(const AliHLTTPCConfMapPoint& src)
	147	{
	148	fHitNumber=src.fHitNumber;
	149	fTrackNumber=src.fTrackNumber;
	150	fNextHitNumber=src.fNextHitNumber;
	151	fUsed=src.fUsed;
	152	fPadrow=src.fPadrow;
	153	fSector=src.fSector;
	154	fx=src.fx;
	155	fy=src.fy;
156	fz=src.fz;
157	fxerr=src.fxerr;
158	fyerr=src.fyerr;
159	fzerr=src.fzerr;
160	fWxy=src.fWxy;
161	fWz=src.fWz;
162	fs=src.fs;
163	fXt=src.fXt;
164	fYt=src.fYt;
165	fZt=src.fZt;
166	fXterr=src.fXterr;
167	fYterr=src.fYterr;
168	fZterr=src.fZterr;
169	fXprime=src.fXprime;
170	fYprime=src.fYprime;
171	fXprimeerr=src.fXprimeerr;
172	fYprimeerr=src.fYprimeerr;
173	fXv=src.fXv;
174	fYv=src.fYv;
175	fZv=src.fZv;
176	fXverr=src.fXverr;
177	fYverr=src.fYverr;
178	fZverr=src.fZverr;
179	fPhi=src.fPhi;
180	fEta=src.fEta;
181	fNextVolumeHit=src.fNextVolumeHit;
182	fNextRowHit=src.fNextRowHit;
183	fNextTrackHit=src.fNextTrackHit;
184	fPhiIndex=src.fPhiIndex;
185	fEtaIndex=src.fEtaIndex;
186	fXYChi2=src.fXYChi2;
187	fSZChi2=src.fSZChi2;
188	fMCTrackID[0]=src.fMCTrackID[0];
189	fMCTrackID[1]=src.fMCTrackID[1];
190	fMCTrackID[2]=src.fMCTrackID[2];
191
192	return *this;
a6c02c85	193	}
	194
	195	AliHLTTPCConfMapPoint::~AliHLTTPCConfMapPoint()
	196	{
	197	// Destructor.
a6c02c85	198	}
a6c02c85	199
055fed30	200	Bool_t AliHLTTPCConfMapPoint::Read(const AliHLTTPCSpacePointData& hit)
a6c02c85	201	{
a6c02c85	202	//read the hits
055fed30	203	SetHitNumber(hit.fID);
a371a266	204	SetPadRow(hit.fPadRow);
a371a266	205	SetSector(hit.GetSlice());
055fed30	206	SetX(hit.fX);
	207	SetY(hit.fY);
	208	SetZ(hit.fZ);
	209	SetXerr(sqrt(hit.fSigmaY2));
	210	SetYerr(sqrt(hit.fSigmaY2));
	211	SetZerr(sqrt(hit.fSigmaZ2));
a6c02c85	212	return kTRUE;
	213	}
	214
	215	void AliHLTTPCConfMapPoint::Reset()
	216	{
	217	//Reset this point.
	218	SetUsage(kFALSE);
	219	SetS(0);
055fed30	220	fNextRowHit = NULL;
	221	fNextVolumeHit=NULL;
	222	fNextTrackHit=NULL;
a6c02c85	223	}
	224
	225	void AliHLTTPCConfMapPoint::Setup(AliHLTTPCVertex *vertex)
	226	{
	227	//Setup. Sets the vertex, conformal coordinates,
	228	//and phi and eta of each hit.
	229
	230	SetIntPoint(vertex->GetX(), vertex->GetY(), vertex->GetZ(),
	231	vertex->GetXErr(), vertex->GetYErr(), vertex->GetZErr());
	232	SetShiftedCoord();
	233	SetConfCoord();
	234	// The angles are set properly if they are set after
	235	// the interaction point and the shifted coordinates
	236	SetAngles();
	237	//SetDist(0., 0.);
	238	return;
	239	}
	240
	241	void AliHLTTPCConfMapPoint::SetIntPoint(Double_t inx, Double_t iny, Double_t inz,
	242	Double_t inxerr, Double_t inyerr, Double_t inzerr)
	243	{
	244	// Defines a new interaction point. This point is needed to calculate
	245	// the conformal coordinates.
	246
	247	SetXt(inx);
	248	SetYt(iny);
	249	SetZt(inz);
	250	SetXterr(inxerr);
	251	SetYterr(inyerr);
	252	SetZterr(inzerr);
	253
	254	return;
	255	}
	256
	257	void AliHLTTPCConfMapPoint::SetAllCoord(const AliHLTTPCConfMapPoint *precedinghit)
	258	{
	259	// Sets the interaction point, the shifted coordinates, and the conformal mapping coordinates.
	260	// These values are calculated from the interaction point of the given cluster which should be a
	261	// already found cluster on the same track.
	262
	263	if (this == precedinghit) {
	264	SetIntPoint(precedinghit->GetX(), precedinghit->GetY(), precedinghit->GetZ(),
	265	precedinghit->GetXerr(), precedinghit->GetYerr(), precedinghit->GetZerr());
	266	}
	267
	268	else {
	269	SetIntPoint(precedinghit->GetXt(), precedinghit->GetYt(), precedinghit->GetZt(),
	270	precedinghit->GetXterr(), precedinghit->GetYterr(), precedinghit->GetZterr());
	271	}
	272
	273	SetShiftedCoord();
	274	SetConfCoord();
	275
	276	return;
	277	}
	278
	279	void AliHLTTPCConfMapPoint::SetShiftedCoord()
	280	{
	281	// Sets the coordinates with resepct to the given vertex point
	282
	283	SetXv(GetX() - fXt);
	284	SetYv(GetY() - fYt);
	285	SetZv(GetZ() - fZt);
	286	/*
287	SetXverr(TMath::Sqrt(GetXerr()GetXerr() + fXterrfXterr));
288	SetYverr(TMath::Sqrt(GetYerr()GetYerr() + fYterrfYterr));
289	SetZverr(TMath::Sqrt(GetZerr()GetZerr() + fZterrfZterr));
290	*/
291	return;
292	}
293
294	void AliHLTTPCConfMapPoint::SetConfCoord()
295	{
296	// Calculates the conformal coordinates of one cluster.
297	// If the option "vertex_constraint" applies the interaction point is
298	// assumed to be at (0, 0, 0). Otherwise the function will use the
299	// interaction point specified by fXt and fYt.
300
301	if(fgDontMap){
302	fXprime = fx;
303	fYprime = fy;
304	fWxy = 0;
305	fs = 0; //track trajectory
306	fWz = 0;
307	return;
308	}
309
310	Double_t r2;
311	Double_t xyErrorScale = 1;
312	Double_t szErrorScale = 1;
313
314	if ((r2 = fXvfXv + fYvfYv))
315	{
316	fXprime = fXv / r2;
317	fYprime = -fYv / r2;
318
319	//set weights:
320	fWxy = r2r2 / ((xyErrorScalexyErrorScale)((fxerrfxerr)+(fyerr*fyerr)));
321	fs = 0; //track trajectory
322	fWz = (Double_t)(1./(szErrorScalefzerrfzerr));
323	} else {
324	fXprime = 0.;
325	fYprime = 0.;
326	fXprimeerr = 0.;
327	fYprimeerr = 0.;
328	fWxy = 0;
329	fWz = 0;
330	fs = 0;
331	}
332
333	return;
334	}
335
336	void AliHLTTPCConfMapPoint::SetAngles()
337	{
338	// Calculates the angle phi and the pseudorapidity eta for each cluster.
339	/*
340	Double_t r = TMath::Sqrt(xx + yy);
341
342	fPhi = TMath::ATan2(y,x);
343	if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
344	fEta = 3.z/(TMath::Abs(z)+2.r);
345	return;
346	*/
347	// Double_t r3dim = TMath::Sqrt(fXvfXv + fYvfYv + fZv*fZv);
348	Double_t r3dim = sqrt(fXvfXv + fYvfYv + fZv*fZv);
349	//Double_t r2dim = TMath::Sqrt(fXvfXv + fYvfYv);
350
351	/*if (r2dim == 0.) {
352	// If r2dim == 0 the pseudorapidity eta cannot be calculated (division by zero)!
353	// This can only happen if the point is lying on the z-axis and this should never be possible.
354	cerr << "The pseudorapidity eta cannot be calculated (division by zero)! Set to 1.e-10." << endl;
355	r2dim = 1.e-10;
356	}
357
358	if (fXv == 0.) {
359	fPhi = (fYv > 0.) ? TMath::Pi() / 2. : - TMath::Pi() / 2.;
360	}
361
362	else {
363	fPhi = (fXv > 0.) ? TMath::ASin(fYv/r2dim) : TMath::Pi() - TMath::ASin(fYv/r2dim);
364	}
365
366	if (fPhi < 0.) {
367	fPhi += 2. * TMath::Pi();
368	}
369	*/
370	//fPhi = TMath::ATan2(y,x);
371	fPhi = atan2(fy,fx);
372	//if(fPhi<0) fPhi = fPhi + 2*TMath::Pi();
373
374	//fEta = 0.5 * TMath::Log((r3dim + fZv)/(r3dim - fZv));
375	fEta = 0.5 * log((r3dim + fZv)/(r3dim - fZv));
376	return;
377	}
378
379	/*
380	AliHLTTPCConfMapTrack AliHLTTPCConfMapPoint::GetTrack(TClonesArray tracks) const
381	{
382	// Returns the pointer to the track to which this hit belongs.
383
384	return (AliHLTTPCConfMapTrack*)tracks->At(this->GetTrackNumber());
385	}
386	*/