[u/mrichter/AliRoot.git] / HLT / TPCLib / tracking-ca / AliHLTTPCCAParam.cxx

// @(#) $Id$
// **************************************************************************
// This file is property of and copyright by the ALICE HLT Project          *
// ALICE Experiment at CERN, All rights reserved.                           *
//                                                                          *
// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
//                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
//                  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.                    *
//                                                                          *
//***************************************************************************


#include "AliHLTTPCCAParam.h"
#include "AliHLTTPCCAMath.h"


#if !defined(HLTCA_GPUCODE)

GPUdi() AliHLTTPCCAParam::AliHLTTPCCAParam()
    : fISlice( 0 ), fNRows( 63 ), fAlpha( 0.174533 ), fDAlpha( 0.349066 ),
    fCosAlpha( 0 ), fSinAlpha( 0 ), fAngleMin( 0 ), fAngleMax( 0 ), fRMin( 83.65 ), fRMax( 133.3 ),
    fZMin( 0.0529937 ), fZMax( 249.778 ), fErrX( 0 ), fErrY( 0 ), fErrZ( 0.228808 ), fPadPitch( 0.4 ), fBzkG( -5.00668 ),
    fConstBz( -5.00668*0.000299792458 ), fHitPickUpFactor( 1. ),
      fMaxTrackMatchDRow( 4 ), fNeighboursSearchArea(3.), fTrackConnectionFactor( 3.5 ), fTrackChiCut( 3.5 ), fTrackChi2Cut( 10 ), fClusterError2CorrectionY(1.), fClusterError2CorrectionZ(1.),
      fMinNTrackClusters( 30 ),
      fMaxTrackQPt(1./0.1)
{
  // constructor
  fParamS0Par[0][0][0] = 0.00047013;
  fParamS0Par[0][0][1] = 2.00135e-05;
  fParamS0Par[0][0][2] = 0.0106533;
  fParamS0Par[0][0][3] = 5.27104e-08;
  fParamS0Par[0][0][4] = 0.012829;
  fParamS0Par[0][0][5] = 0.000147125;
  fParamS0Par[0][0][6] = 4.99432;
  fParamS0Par[0][1][0] = 0.000883342;
  fParamS0Par[0][1][1] = 1.07011e-05;
  fParamS0Par[0][1][2] = 0.0103187;
  fParamS0Par[0][1][3] = 4.25141e-08;
  fParamS0Par[0][1][4] = 0.0224292;
  fParamS0Par[0][1][5] = 8.27274e-05;
  fParamS0Par[0][1][6] = 4.17233;
  fParamS0Par[0][2][0] = 0.000745399;
  fParamS0Par[0][2][1] = 5.62408e-06;
  fParamS0Par[0][2][2] = 0.0151562;
  fParamS0Par[0][2][3] = 5.08757e-08;
  fParamS0Par[0][2][4] = 0.0601004;
  fParamS0Par[0][2][5] = 7.97129e-05;
  fParamS0Par[0][2][6] = 4.84913;
  fParamS0Par[1][0][0] = 0.00215126;
  fParamS0Par[1][0][1] = 6.82233e-05;
  fParamS0Par[1][0][2] = 0.0221867;
  fParamS0Par[1][0][3] = -6.27825e-09;
  fParamS0Par[1][0][4] = -0.00745378;
  fParamS0Par[1][0][5] = 0.000172629;
  fParamS0Par[1][0][6] = 6.24987;
  fParamS0Par[1][1][0] = 0.00181667;
  fParamS0Par[1][1][1] = -4.17772e-06;
  fParamS0Par[1][1][2] = 0.0253429;
  fParamS0Par[1][1][3] = 1.3011e-07;
  fParamS0Par[1][1][4] = -0.00362827;
  fParamS0Par[1][1][5] = 0.00030406;
  fParamS0Par[1][1][6] = 17.7775;
  fParamS0Par[1][2][0] = 0.00158251;
  fParamS0Par[1][2][1] = -3.55911e-06;
  fParamS0Par[1][2][2] = 0.0247899;
  fParamS0Par[1][2][3] = 7.20604e-08;
  fParamS0Par[1][2][4] = 0.0179946;
  fParamS0Par[1][2][5] = 0.000425504;
  fParamS0Par[1][2][6] = 20.9294;

  for( int i=0; i<200; i++ ) fRowX[i] = 0;

  Update();
}

void AliHLTTPCCAParam::Initialize( int iSlice,
    int nRows, float rowX[],
    float alpha, float dAlpha,
    float rMin, float rMax,
    float zMin, float zMax,
    float padPitch, float zSigma,
    float bz
                                        )
{
  // initialization
  fISlice = iSlice;
  fAlpha = alpha;
  fDAlpha = dAlpha;
  fRMin = rMin;
  fRMax = rMax;
  fZMin = zMin;
  fZMax = zMax;
  fPadPitch = padPitch;
  fErrY = 1.; // not in use
  fErrZ = zSigma;
  fBzkG = bz;
  fNRows = nRows;
  for ( int irow = 0; irow < nRows; irow++ ) {
    fRowX[irow] = rowX[irow];
    //std::cout << " row " << irow << " x= " << rowX[irow] << std::endl;
  }

  Update();
}

void AliHLTTPCCAParam::Update()
{
  // update of calculated values

  const double kCLight = 0.000299792458;
  fConstBz = fBzkG * kCLight;

  fPolinomialFieldBz[0] = fConstBz * (  0.999286   );
  fPolinomialFieldBz[1] = fConstBz * ( -4.54386e-7 );
  fPolinomialFieldBz[2] = fConstBz * (  2.32950e-5 );
  fPolinomialFieldBz[3] = fConstBz * ( -2.99912e-7 );
  fPolinomialFieldBz[4] = fConstBz * ( -2.03442e-8 );
  fPolinomialFieldBz[5] = fConstBz * (  9.71402e-8 );

  fCosAlpha = CAMath::Cos( fAlpha );
  fSinAlpha = CAMath::Sin( fAlpha );
  fAngleMin = fAlpha - fDAlpha / 2.f;
  fAngleMax = fAlpha + fDAlpha / 2.f;
  fErrX = fPadPitch / CAMath::Sqrt( 12. );
  fTrackChi2Cut = fTrackChiCut * fTrackChiCut;
}

#endif


MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::Slice2Global( float x, float y,  float z,
    float *X, float *Y,  float *Z ) const
{
  // conversion of coorinates sector->global
  *X = x * fCosAlpha - y * fSinAlpha;
  *Y = y * fCosAlpha + x * fSinAlpha;
  *Z = z;
}

MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::Global2Slice( float X, float Y,  float Z,
    float *x, float *y,  float *z ) const
{
  // conversion of coorinates global->sector
  *x = X * fCosAlpha + Y * fSinAlpha;
  *y = Y * fCosAlpha - X * fSinAlpha;
  *z = Z;
}

MEM_CLASS_PRE() GPUdi() float MEM_LG(AliHLTTPCCAParam)::GetClusterError2( int yz, int type, float z, float angle ) const
{
  //* recalculate the cluster error wih respect to the track slope

  float angle2 = angle * angle;
  MakeType(const float*) c = fParamS0Par[yz][type];
  float v = c[0] + z * ( c[1] + c[3] * z ) + angle2 * ( c[2] + angle2 * c[4] + c[5] * z );
  return CAMath::Abs( v );
}

MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::GetClusterErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
{
  //
  // Use calibrated cluster error from OCDB
  //

  z = CAMath::Abs( ( 250. - 0.275 ) - CAMath::Abs( z ) );
  int    type = ( iRow < 63 ) ? 0 : ( ( iRow > 126 ) ? 1 : 2 );
  float cosPhiInv = CAMath::Abs( cosPhi ) > 1.e-2 ? 1. / cosPhi : 0;
  float angleY = sinPhi * cosPhiInv ; // dy/dx
  float angleZ = DzDs * cosPhiInv ; // dz/dx

  Err2Y = GetClusterError2( 0, type, z, angleY );
  Err2Z = GetClusterError2( 1, type, z, angleZ );
}

MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::GetClusterErrors2v1( int rowType, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
{
  //
  // Use calibrated cluster error from OCDB
  //

  z = CAMath::Abs( ( 250. - 0.275 ) - CAMath::Abs( z ) );
  float cosPhiInv = CAMath::Abs( cosPhi ) > 1.e-2 ? 1. / cosPhi : 0;
  float angleY = sinPhi * cosPhiInv ; // dy/dx
  float angleZ = DzDs * cosPhiInv ; // dz/dx

  Err2Y = GetClusterError2( 0, rowType, z, angleY );
  Err2Z = GetClusterError2( 1, rowType, z, angleZ );
}

#ifndef HLTCA_GPUCODE
GPUh() void AliHLTTPCCAParam::WriteSettings( std::ostream &out ) const
{
  // write settings to the file
  out << fISlice << std::endl;
  out << fNRows << std::endl;
  out << fAlpha << std::endl;
  out << fDAlpha << std::endl;
  out << fCosAlpha << std::endl;
  out << fSinAlpha << std::endl;
  out << fAngleMin << std::endl;
  out << fAngleMax << std::endl;
  out << fRMin << std::endl;
  out << fRMax << std::endl;
  out << fZMin << std::endl;
  out << fZMax << std::endl;
  out << fErrX << std::endl;
  out << fErrY << std::endl;
  out << fErrZ << std::endl;
  out << fPadPitch << std::endl;
  out << fBzkG << std::endl;
  out << fHitPickUpFactor << std::endl;
  out << fMaxTrackMatchDRow << std::endl;
  out << fTrackConnectionFactor << std::endl;
  out << fTrackChiCut << std::endl;
  out << fTrackChi2Cut << std::endl;
  for ( int iRow = 0; iRow < fNRows; iRow++ ) {
    out << fRowX[iRow] << std::endl;
  }
  out << std::endl;
  for ( int i = 0; i < 2; i++ )
    for ( int j = 0; j < 3; j++ )
      for ( int k = 0; k < 7; k++ )
        out << fParamS0Par[i][j][k] << std::endl;
  out << std::endl;
}

GPUh() void AliHLTTPCCAParam::ReadSettings( std::istream &in )
{
  // Read settings from the file

  in >> fISlice;
  in >> fNRows;
  in >> fAlpha;
  in >> fDAlpha;
  in >> fCosAlpha;
  in >> fSinAlpha;
  in >> fAngleMin;
  in >> fAngleMax;
  in >> fRMin;
  in >> fRMax;
  in >> fZMin;
  in >> fZMax;
  in >> fErrX;
  in >> fErrY;
  in >> fErrZ;
  in >> fPadPitch;
  in >> fBzkG;
  in >> fHitPickUpFactor;
  in >> fMaxTrackMatchDRow;
  in >> fTrackConnectionFactor;
  in >> fTrackChiCut;
  in >> fTrackChi2Cut;

  if( fNRows<0 || fNRows > 200 ) fNRows = 0;

  for ( int iRow = 0; iRow < fNRows; iRow++ ) {
    in >> fRowX[iRow];
  }
  for ( int i = 0; i < 2; i++ )
    for ( int j = 0; j < 3; j++ )
      for ( int k = 0; k < 7; k++ )
        in >> fParamS0Par[i][j][k];
}
#endif
Commit	Line	Data
326c2d4b	1	// @(#) $Id$
ce565086	2	// **************************************************************************
fbb9b71b	3	// This file is property of and copyright by the ALICE HLT Project *
d54804bf	4	// ALICE Experiment at CERN, All rights reserved. *
	5	// *
	6	// Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
	7	// Ivan Kisel <kisel@kip.uni-heidelberg.de> *
	8	// for The ALICE HLT Project. *
	9	// *
	10	// Permission to use, copy, modify and distribute this software and its *
	11	// documentation strictly for non-commercial purposes is hereby granted *
	12	// without fee, provided that the above copyright notice appears in all *
	13	// copies and that both the copyright notice and this permission notice *
	14	// appear in the supporting documentation. The authors make no claims *
	15	// about the suitability of this software for any purpose. It is *
	16	// provided "as is" without express or implied warranty. *
ce565086	17	// *
d54804bf	18	//***************************************************************************
326c2d4b	19
ce565086	20
326c2d4b	21	#include "AliHLTTPCCAParam.h"
00d07bcd	22	#include "AliHLTTPCCAMath.h"
326c2d4b	23
326c2d4b	24
fbb9b71b	25	#if !defined(HLTCA_GPUCODE)
00d07bcd	26
f0bada7f	27	GPUdi() AliHLTTPCCAParam::AliHLTTPCCAParam()
fbb9b71b	28	: fISlice( 0 ), fNRows( 63 ), fAlpha( 0.174533 ), fDAlpha( 0.349066 ),
fbb9b71b	29	fCosAlpha( 0 ), fSinAlpha( 0 ), fAngleMin( 0 ), fAngleMax( 0 ), fRMin( 83.65 ), fRMax( 133.3 ),
a8714ffa	30	fZMin( 0.0529937 ), fZMax( 249.778 ), fErrX( 0 ), fErrY( 0 ), fErrZ( 0.228808 ), fPadPitch( 0.4 ), fBzkG( -5.00668 ),
a8714ffa	31	fConstBz( -5.00668*0.000299792458 ), fHitPickUpFactor( 1. ),
36e3690e	32	fMaxTrackMatchDRow( 4 ), fNeighboursSearchArea(3.), fTrackConnectionFactor( 3.5 ), fTrackChiCut( 3.5 ), fTrackChi2Cut( 10 ), fClusterError2CorrectionY(1.), fClusterError2CorrectionZ(1.),
	33	fMinNTrackClusters( 30 ),
	34	fMaxTrackQPt(1./0.1)
326c2d4b	35	{
00d07bcd	36	// constructor
eb30eb49	37	fParamS0Par[0][0][0] = 0.00047013;
	38	fParamS0Par[0][0][1] = 2.00135e-05;
	39	fParamS0Par[0][0][2] = 0.0106533;
	40	fParamS0Par[0][0][3] = 5.27104e-08;
	41	fParamS0Par[0][0][4] = 0.012829;
	42	fParamS0Par[0][0][5] = 0.000147125;
	43	fParamS0Par[0][0][6] = 4.99432;
	44	fParamS0Par[0][1][0] = 0.000883342;
	45	fParamS0Par[0][1][1] = 1.07011e-05;
	46	fParamS0Par[0][1][2] = 0.0103187;
	47	fParamS0Par[0][1][3] = 4.25141e-08;
	48	fParamS0Par[0][1][4] = 0.0224292;
	49	fParamS0Par[0][1][5] = 8.27274e-05;
	50	fParamS0Par[0][1][6] = 4.17233;
	51	fParamS0Par[0][2][0] = 0.000745399;
	52	fParamS0Par[0][2][1] = 5.62408e-06;
	53	fParamS0Par[0][2][2] = 0.0151562;
	54	fParamS0Par[0][2][3] = 5.08757e-08;
	55	fParamS0Par[0][2][4] = 0.0601004;
	56	fParamS0Par[0][2][5] = 7.97129e-05;
	57	fParamS0Par[0][2][6] = 4.84913;
	58	fParamS0Par[1][0][0] = 0.00215126;
	59	fParamS0Par[1][0][1] = 6.82233e-05;
	60	fParamS0Par[1][0][2] = 0.0221867;
	61	fParamS0Par[1][0][3] = -6.27825e-09;
	62	fParamS0Par[1][0][4] = -0.00745378;
	63	fParamS0Par[1][0][5] = 0.000172629;
	64	fParamS0Par[1][0][6] = 6.24987;
	65	fParamS0Par[1][1][0] = 0.00181667;
	66	fParamS0Par[1][1][1] = -4.17772e-06;
	67	fParamS0Par[1][1][2] = 0.0253429;
	68	fParamS0Par[1][1][3] = 1.3011e-07;
	69	fParamS0Par[1][1][4] = -0.00362827;
	70	fParamS0Par[1][1][5] = 0.00030406;
	71	fParamS0Par[1][1][6] = 17.7775;
	72	fParamS0Par[1][2][0] = 0.00158251;
	73	fParamS0Par[1][2][1] = -3.55911e-06;
	74	fParamS0Par[1][2][2] = 0.0247899;
	75	fParamS0Par[1][2][3] = 7.20604e-08;
	76	fParamS0Par[1][2][4] = 0.0179946;
	77	fParamS0Par[1][2][5] = 0.000425504;
	78	fParamS0Par[1][2][6] = 20.9294;
	79
ea30c0aa	80	for( int i=0; i<200; i++ ) fRowX[i] = 0;
15d2e9cf	81
326c2d4b	82	Update();
	83	}
	84
7be9b0d7	85	void AliHLTTPCCAParam::Initialize( int iSlice,
fbb9b71b	86	int nRows, float rowX[],
	87	float alpha, float dAlpha,
	88	float rMin, float rMax,
	89	float zMin, float zMax,
	90	float padPitch, float zSigma,
	91	float bz
	92	)
326c2d4b	93	{
fbb9b71b	94	// initialization
d54804bf	95	fISlice = iSlice;
	96	fAlpha = alpha;
	97	fDAlpha = dAlpha;
	98	fRMin = rMin;
	99	fRMax = rMax;
	100	fZMin = zMin;
	101	fZMax = zMax;
	102	fPadPitch = padPitch;
326c2d4b	103	fErrY = 1.; // not in use
d54804bf	104	fErrZ = zSigma;
91794c67	105	fBzkG = bz;
d54804bf	106	fNRows = nRows;
fbb9b71b	107	for ( int irow = 0; irow < nRows; irow++ ) {
d54804bf	108	fRowX[irow] = rowX[irow];
c1cab320	109	//std::cout << " row " << irow << " x= " << rowX[irow] << std::endl;
dc4788ec	110	}
dc4788ec	111
326c2d4b	112	Update();
	113	}
	114
7be9b0d7	115	void AliHLTTPCCAParam::Update()
326c2d4b	116	{
326c2d4b	117	// update of calculated values
91794c67	118
	119	const double kCLight = 0.000299792458;
	120	fConstBz = fBzkG * kCLight;
	121
	122	fPolinomialFieldBz[0] = fConstBz * ( 0.999286 );
	123	fPolinomialFieldBz[1] = fConstBz * ( -4.54386e-7 );
	124	fPolinomialFieldBz[2] = fConstBz * ( 2.32950e-5 );
	125	fPolinomialFieldBz[3] = fConstBz * ( -2.99912e-7 );
	126	fPolinomialFieldBz[4] = fConstBz * ( -2.03442e-8 );
	127	fPolinomialFieldBz[5] = fConstBz * ( 9.71402e-8 );
	128
fbb9b71b	129	fCosAlpha = CAMath::Cos( fAlpha );
fbb9b71b	130	fSinAlpha = CAMath::Sin( fAlpha );
7be9b0d7	131	fAngleMin = fAlpha - fDAlpha / 2.f;
7be9b0d7	132	fAngleMax = fAlpha + fDAlpha / 2.f;
fbb9b71b	133	fErrX = fPadPitch / CAMath::Sqrt( 12. );
326c2d4b	134	fTrackChi2Cut = fTrackChiCut * fTrackChiCut;
	135	}
	136
7be9b0d7	137	#endif
	138
	139
43422963	140	MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::Slice2Global( float x, float y, float z,
fbb9b71b	141	float X, float Y, float *Z ) const
fbb9b71b	142	{
326c2d4b	143	// conversion of coorinates sector->global
fbb9b71b	144	X = x fCosAlpha - y * fSinAlpha;
fbb9b71b	145	Y = y fCosAlpha + x * fSinAlpha;
326c2d4b	146	*Z = z;
326c2d4b	147	}
fbb9b71b	148
43422963	149	MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::Global2Slice( float X, float Y, float Z,
fbb9b71b	150	float x, float y, float *z ) const
326c2d4b	151	{
326c2d4b	152	// conversion of coorinates global->sector
fbb9b71b	153	x = X fCosAlpha + Y * fSinAlpha;
fbb9b71b	154	y = Y fCosAlpha - X * fSinAlpha;
326c2d4b	155	*z = Z;
326c2d4b	156	}
eb30eb49	157
43422963	158	MEM_CLASS_PRE() GPUdi() float MEM_LG(AliHLTTPCCAParam)::GetClusterError2( int yz, int type, float z, float angle ) const
eb30eb49	159	{
eb30eb49	160	//* recalculate the cluster error wih respect to the track slope
6de2bc40	161
fbb9b71b	162	float angle2 = angle * angle;
43422963	163	MakeType(const float*) c = fParamS0Par[yz][type];
fbb9b71b	164	float v = c[0] + z * ( c[1] + c[3] * z ) + angle2 * ( c[2] + angle2 * c[4] + c[5] * z );
fbb9b71b	165	return CAMath::Abs( v );
eb30eb49	166	}
eb30eb49	167
43422963	168	MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::GetClusterErrors2( int iRow, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
63d8b79d	169	{
	170	//
	171	// Use calibrated cluster error from OCDB
	172	//
	173
fbb9b71b	174	z = CAMath::Abs( ( 250. - 0.275 ) - CAMath::Abs( z ) );
	175	int type = ( iRow < 63 ) ? 0 : ( ( iRow > 126 ) ? 1 : 2 );
	176	float cosPhiInv = CAMath::Abs( cosPhi ) > 1.e-2 ? 1. / cosPhi : 0;
6de2bc40	177	float angleY = sinPhi * cosPhiInv ; // dy/dx
6de2bc40	178	float angleZ = DzDs * cosPhiInv ; // dz/dx
63d8b79d	179
fbb9b71b	180	Err2Y = GetClusterError2( 0, type, z, angleY );
fbb9b71b	181	Err2Z = GetClusterError2( 1, type, z, angleZ );
63d8b79d	182	}
63d8b79d	183
43422963	184	MEM_CLASS_PRE() GPUdi() void MEM_LG(AliHLTTPCCAParam)::GetClusterErrors2v1( int rowType, float z, float sinPhi, float cosPhi, float DzDs, float &Err2Y, float &Err2Z ) const
6d869045	185	{
	186	//
	187	// Use calibrated cluster error from OCDB
	188	//
	189
	190	z = CAMath::Abs( ( 250. - 0.275 ) - CAMath::Abs( z ) );
	191	float cosPhiInv = CAMath::Abs( cosPhi ) > 1.e-2 ? 1. / cosPhi : 0;
	192	float angleY = sinPhi * cosPhiInv ; // dy/dx
	193	float angleZ = DzDs * cosPhiInv ; // dz/dx
	194
	195	Err2Y = GetClusterError2( 0, rowType, z, angleY );
	196	Err2Z = GetClusterError2( 1, rowType, z, angleZ );
	197	}
	198
c7d6f78b	199	#ifndef HLTCA_GPUCODE
fbb9b71b	200	GPUh() void AliHLTTPCCAParam::WriteSettings( std::ostream &out ) const
eb30eb49	201	{
00d07bcd	202	// write settings to the file
fbb9b71b	203	out << fISlice << std::endl;
	204	out << fNRows << std::endl;
	205	out << fAlpha << std::endl;
	206	out << fDAlpha << std::endl;
	207	out << fCosAlpha << std::endl;
	208	out << fSinAlpha << std::endl;
	209	out << fAngleMin << std::endl;
	210	out << fAngleMax << std::endl;
	211	out << fRMin << std::endl;
	212	out << fRMax << std::endl;
	213	out << fZMin << std::endl;
	214	out << fZMax << std::endl;
	215	out << fErrX << std::endl;
	216	out << fErrY << std::endl;
	217	out << fErrZ << std::endl;
	218	out << fPadPitch << std::endl;
91794c67	219	out << fBzkG << std::endl;
fbb9b71b	220	out << fHitPickUpFactor << std::endl;
	221	out << fMaxTrackMatchDRow << std::endl;
	222	out << fTrackConnectionFactor << std::endl;
	223	out << fTrackChiCut << std::endl;
	224	out << fTrackChi2Cut << std::endl;
	225	for ( int iRow = 0; iRow < fNRows; iRow++ ) {
	226	out << fRowX[iRow] << std::endl;
eb30eb49	227	}
fbb9b71b	228	out << std::endl;
	229	for ( int i = 0; i < 2; i++ )
	230	for ( int j = 0; j < 3; j++ )
	231	for ( int k = 0; k < 7; k++ )
	232	out << fParamS0Par[i][j][k] << std::endl;
	233	out << std::endl;
eb30eb49	234	}
eb30eb49	235
00d07bcd	236	GPUh() void AliHLTTPCCAParam::ReadSettings( std::istream &in )
eb30eb49	237	{
00d07bcd	238	// Read settings from the file
00d07bcd	239
eb30eb49	240	in >> fISlice;
	241	in >> fNRows;
	242	in >> fAlpha;
	243	in >> fDAlpha;
	244	in >> fCosAlpha;
	245	in >> fSinAlpha;
	246	in >> fAngleMin;
	247	in >> fAngleMax;
	248	in >> fRMin;
	249	in >> fRMax;
	250	in >> fZMin;
	251	in >> fZMax;
	252	in >> fErrX;
	253	in >> fErrY;
	254	in >> fErrZ;
	255	in >> fPadPitch;
91794c67	256	in >> fBzkG;
693d2443	257	in >> fHitPickUpFactor;
eb30eb49	258	in >> fMaxTrackMatchDRow;
	259	in >> fTrackConnectionFactor;
	260	in >> fTrackChiCut;
	261	in >> fTrackChi2Cut;
ea30c0aa	262
	263	if( fNRows<0 \|\| fNRows > 200 ) fNRows = 0;
	264
fbb9b71b	265	for ( int iRow = 0; iRow < fNRows; iRow++ ) {
eb30eb49	266	in >> fRowX[iRow];
eb30eb49	267	}
fbb9b71b	268	for ( int i = 0; i < 2; i++ )
	269	for ( int j = 0; j < 3; j++ )
	270	for ( int k = 0; k < 7; k++ )
	271	in >> fParamS0Par[i][j][k];
eb30eb49	272	}
c7d6f78b	273	#endif