[u/mrichter/AliRoot.git] / TRD / AliTRDrecoParam.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.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  Parameter class for the TRD reconstruction                               //
//                                                                           //
//  Authors:                                                                 //
//    Alex Bercuci <A.Bercuci@gsi.de>                                        //
//    Markus Fasel <M.Fasel@gsi.de>                                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "AliLog.h"

#include "AliTRDrecoParam.h"

ClassImp(AliTRDrecoParam)


//______________________________________________________________
AliTRDrecoParam::AliTRDrecoParam()
  :AliDetectorRecoParam()
  ,fkdNchdy(12.)
  ,fkMaxTheta(1.0)	
  ,fkMaxPhi(2.0) 
  ,fkRoad0y(6.0)
  ,fkRoad0z(8.5) 
  ,fkRoad1y(2.0)
  ,fkRoad1z(20.0)	
  ,fkRoad2y(3.0)
  ,fkRoad2z(20.0)
  ,fkPtThreshold(2.0) 
  ,fkPlaneQualityThreshold(5.0)// 4.2? under Investigation
  ,fkRoadzMultiplicator(1.5)
  ,fkFindable(.333)
  ,fkChi2Z(30./*14.*//*12.5*/)
  ,fkChi2Y(.25)
  ,fkChi2YSlope(7.73)
  ,fkChi2ZSlope(0.069)
  ,fkChi2YCut(0.5)
  ,fkPhiSlope(10.6)
  ,fkNMeanClusters(20.)
  ,fkNSigmaClusters(2.)
  ,fkNClusterNoise(0.)
  ,fkNMeanTracklets(5.5)
  ,fkTrackLikelihood(-15.)
  ,fNumberOfConfigs(3)
  ,fFlags(0)
  ,fRawStreamVersion("DEFAULT")
  ,fMinMaxCutSigma(4.)
  ,fMinLeftRightCutSigma(8.)
  ,fClusMaxThresh(4.5)
  ,fClusSigThresh(3.5)
  ,fTCnexp(1)
  ,fRecEveryNTB(1)
  ,fNumberOfPresamples(0)
  ,fNumberOfPostsamples(0)
{
  //
  // Default constructor
  //
  fSysCovMatrix[0] = 0.; // y direction (1 cm)
  fSysCovMatrix[1] = 0.; // z direction (1 cm)
  fSysCovMatrix[2] = 0.; // snp
  fSysCovMatrix[3] = 0.; // tgl
  fSysCovMatrix[4] = 0.; // 1/pt

  // Xe tail cancellation parameters
  fTCParams[0] = 1.156; // r1
  fTCParams[1] = 0.130; // r2
  fTCParams[2] = 0.114; // c1
  fTCParams[3] = 0.624; // c2
  // Ar tail cancellation parameters
  fTCParams[4] = 6.;    // r1
  fTCParams[5] = 0.62;  // r2
  fTCParams[6] = 0.0087;// c1
  fTCParams[7] = 0.07;  // c2

  memset(fPIDThreshold, 0, AliTRDCalPID::kNMom*sizeof(Double_t));
  memset(fStreamLevel, 0, kTRDreconstructionTasks * sizeof(Int_t));

  SetPIDmethod(AliTRDPIDResponse::kLQ1D);
  SetEightSlices();
  SetImproveTracklets();
  SetLUT();
  SetTailCancelation();
}

//______________________________________________________________
AliTRDrecoParam::AliTRDrecoParam(const AliTRDrecoParam &ref)
  :AliDetectorRecoParam(ref)
  ,fkdNchdy(ref.fkdNchdy)
  ,fkMaxTheta(ref.fkMaxTheta)
  ,fkMaxPhi(ref.fkMaxPhi)
  ,fkRoad0y(ref.fkRoad0y)
  ,fkRoad0z(ref.fkRoad0z)
  ,fkRoad1y(ref.fkRoad1y)
  ,fkRoad1z(ref.fkRoad1z)
  ,fkRoad2y(ref.fkRoad2y)
  ,fkRoad2z(ref.fkRoad2z)
  ,fkPtThreshold(ref.fkPtThreshold)
  ,fkPlaneQualityThreshold(ref.fkPlaneQualityThreshold)
  ,fkRoadzMultiplicator(ref.fkRoadzMultiplicator)
  ,fkFindable(ref.fkFindable)
  ,fkChi2Z(ref.fkChi2Z)
  ,fkChi2Y(ref.fkChi2Y)
  ,fkChi2YSlope(ref.fkChi2YSlope)
  ,fkChi2ZSlope(ref.fkChi2ZSlope)
  ,fkChi2YCut(ref.fkChi2YCut)
  ,fkPhiSlope(ref.fkPhiSlope)
  ,fkNMeanClusters(ref.fkNMeanClusters)
  ,fkNSigmaClusters(ref.fkNSigmaClusters)
  ,fkNClusterNoise(ref.fkNClusterNoise)
  ,fkNMeanTracklets(ref.fkNMeanTracklets)
  ,fkTrackLikelihood(ref.fkTrackLikelihood)
  ,fNumberOfConfigs(ref.fNumberOfConfigs)
  ,fFlags(ref.fFlags)
  ,fRawStreamVersion(ref.fRawStreamVersion)
  ,fMinMaxCutSigma(ref.fMinMaxCutSigma)
  ,fMinLeftRightCutSigma(ref.fMinLeftRightCutSigma)
  ,fClusMaxThresh(ref.fClusMaxThresh)
  ,fClusSigThresh(ref.fClusSigThresh)
  ,fTCnexp(ref.fTCnexp)
  ,fRecEveryNTB(ref.fRecEveryNTB)
  ,fNumberOfPresamples(ref.fNumberOfPresamples)
  ,fNumberOfPostsamples(ref.fNumberOfPostsamples)
{
  //
  // Copy constructor
  //
  memcpy(fSysCovMatrix, ref.fSysCovMatrix, 5*sizeof(Double_t));
  memcpy(fTCParams, ref.fTCParams, 8*sizeof(Double_t));
  memcpy(fPIDThreshold, ref.fPIDThreshold, AliTRDCalPID::kNMom*sizeof(Double_t));
  memcpy(fStreamLevel, ref.fStreamLevel, kTRDreconstructionTasks * sizeof(Int_t));
}

//______________________________________________________________
AliTRDrecoParam& AliTRDrecoParam::operator=(const AliTRDrecoParam &ref)
{
  //
  // assignment operator
  //

  if(this == &ref) return *this;
  AliDetectorRecoParam::operator=(ref);
  fkdNchdy              = ref.fkdNchdy;
  fkMaxTheta            = ref.fkMaxTheta;
  fkMaxPhi              = ref.fkMaxPhi;
  fkRoad0y              = ref.fkRoad0y;
  fkRoad0z              = ref.fkRoad0z;
  fkRoad1y              = ref.fkRoad1y;
  fkRoad1z              = ref.fkRoad1z;
  fkRoad2y              = ref.fkRoad2y;
  fkRoad2z              = ref.fkRoad2z;
  fkPtThreshold         = ref.fkPtThreshold;
  fkPlaneQualityThreshold= ref.fkPlaneQualityThreshold;
  fkRoadzMultiplicator  = ref.fkRoadzMultiplicator;
  fkFindable            = ref.fkFindable;
  fkChi2Z               = ref.fkChi2Z;
  fkChi2Y               = ref.fkChi2Y;
  fkChi2YSlope          = ref.fkChi2YSlope;
  fkChi2ZSlope          = ref.fkChi2ZSlope;
  fkChi2YCut            = ref.fkChi2YCut;
  fkPhiSlope            = ref.fkPhiSlope;
  fkNMeanClusters       = ref.fkNMeanClusters;
  fkNSigmaClusters      = ref.fkNSigmaClusters;
  fkNClusterNoise       = ref.fkNClusterNoise;
  fkNMeanTracklets      = ref.fkNMeanTracklets;
  fkTrackLikelihood     = ref.fkTrackLikelihood;
  fNumberOfConfigs      = ref.fNumberOfConfigs;
  fFlags                = ref.fFlags;
  fRawStreamVersion     = ref.fRawStreamVersion;
  fMinMaxCutSigma       = ref.fMinMaxCutSigma;
  fMinLeftRightCutSigma = ref.fMinLeftRightCutSigma;
  fClusMaxThresh        = ref.fClusMaxThresh;
  fClusSigThresh        = ref.fClusSigThresh;
  fTCnexp               = ref.fTCnexp;
  fRecEveryNTB          = ref.fRecEveryNTB;
  fNumberOfPresamples   = ref.fNumberOfPresamples;
  fNumberOfPostsamples  = ref.fNumberOfPostsamples;

  memcpy(fSysCovMatrix, ref.fSysCovMatrix, 5*sizeof(Double_t));
  memcpy(fTCParams, ref.fTCParams, 8*sizeof(Double_t));
  memcpy(fPIDThreshold, ref.fPIDThreshold, AliTRDCalPID::kNMom*sizeof(Double_t));
  memcpy(fStreamLevel, ref.fStreamLevel, kTRDreconstructionTasks * sizeof(Int_t));
  return *this;
}

//______________________________________________________________
AliTRDrecoParam *AliTRDrecoParam::GetLowFluxParam()
{
  //
  // Parameters for the low flux environment
  //

  AliTRDrecoParam *rec = new AliTRDrecoParam();
  rec->fkdNchdy = 12.; // pp in TRD
  rec->SetVertexConstrained();
  rec->SetCheckTimeConsistency();
  return rec;

}

//______________________________________________________________
AliTRDrecoParam *AliTRDrecoParam::GetLowFluxHLTParam()
{
  //
  // Parameters for the high flux environment in HLT
  //

  AliTRDrecoParam *rec = GetLowFluxParam();
  rec->fNumberOfConfigs = 2;
  return rec;

}

//______________________________________________________________
AliTRDrecoParam *AliTRDrecoParam::GetHighFluxParam()
{
  //
  // Parameters for the high flux environment
  //

  AliTRDrecoParam *rec = new AliTRDrecoParam();
  rec->fkdNchdy = 4000.; // PbPb in TRD
  rec->SetVertexConstrained();
  rec->SetCheckTimeConsistency();
  return rec;

}

//______________________________________________________________
AliTRDrecoParam *AliTRDrecoParam::GetHighFluxHLTParam()
{
  //
  // Parameters for the high flux environment in HLT
  //

  AliTRDrecoParam *rec = GetHighFluxParam();
  rec->fNumberOfConfigs = 1;
  return rec;

}

//______________________________________________________________
AliTRDrecoParam *AliTRDrecoParam::GetCosmicTestParam()
{
  //
  // Parameters for the cosmics data
  //

  AliTRDrecoParam *par = new AliTRDrecoParam();
  par->fSysCovMatrix[0] = 2.; // y direction (1 cm)
  par->fSysCovMatrix[1] = 2.; // z direction (1 cm)
  par->fkChi2YSlope     = 0.11853;
  par->fkChi2ZSlope     = 0.04527;
  par->fkChi2YCut       = 1.;
  par->fkPhiSlope       = 10.; //3.17954;
  par->fkMaxTheta       = 2.1445;
  par->fkMaxPhi         = 2.7475;
  par->fkNMeanClusters  = 12.89;
  par->fkNSigmaClusters = 2.095;
  par->fkRoadzMultiplicator = 3.;
  par->fStreamLevel[kTracker] = 1;
  par->SetCheckTimeConsistency();
  return par;

}


//______________________________________________________________
Float_t AliTRDrecoParam::GetNClusters() const
{
  // Estimate the number of clusters in the TRD detector
  
  Float_t nclusters = (fkNMeanClusters + 2*fkNSigmaClusters)*fkNMeanTracklets*fkdNchdy;
  nclusters *= 1.+fkNClusterNoise;
  return nclusters;
}

//______________________________________________________________
void AliTRDrecoParam::SetPIDLQslices(Int_t s)
{
// Setting number of slices used by the PID LQ method s={1, 2}
// If PID NN is set this function will change to PID LQ.
 
  if(IsPIDNeuralNetwork()){
    AliWarning("PID set to NN. Changing to LQ.");
    SetPIDNeuralNetwork(kFALSE);
  } 

  switch(s){
  case 1: 
    if(TESTBIT(fFlags, kLQ2D)) CLRBIT(fFlags, kLQ2D);
    break;
  case 2:
    SETBIT(fFlags, kLQ2D);
    break;
  default:
    AliWarning(Form("N[%d] PID LQ slices not implemented. Using default 2.", s));
    SETBIT(fFlags, kLQ2D);
    break;
  }
}
Commit	Line	Data
	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	/* $Id$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Parameter class for the TRD reconstruction //
	21	// //
	22	// Authors: //
	23	// Alex Bercuci <A.Bercuci@gsi.de> //
	24	// Markus Fasel <M.Fasel@gsi.de> //
	25	// //
	26	///////////////////////////////////////////////////////////////////////////////
	27
	28	#include "AliLog.h"
	29
	30	#include "AliTRDrecoParam.h"
	31
	32	ClassImp(AliTRDrecoParam)
	33
	34
	35	//______________________________________________________________
	36	AliTRDrecoParam::AliTRDrecoParam()
	37	:AliDetectorRecoParam()
	38	,fkdNchdy(12.)
	39	,fkMaxTheta(1.0)
	40	,fkMaxPhi(2.0)
	41	,fkRoad0y(6.0)
	42	,fkRoad0z(8.5)
	43	,fkRoad1y(2.0)
	44	,fkRoad1z(20.0)
	45	,fkRoad2y(3.0)
	46	,fkRoad2z(20.0)
	47	,fkPtThreshold(2.0)
	48	,fkPlaneQualityThreshold(5.0)// 4.2? under Investigation
	49	,fkRoadzMultiplicator(1.5)
	50	,fkFindable(.333)
	51	,fkChi2Z(30./14.//12.5/)
	52	,fkChi2Y(.25)
	53	,fkChi2YSlope(7.73)
	54	,fkChi2ZSlope(0.069)
	55	,fkChi2YCut(0.5)
	56	,fkPhiSlope(10.6)
	57	,fkNMeanClusters(20.)
	58	,fkNSigmaClusters(2.)
	59	,fkNClusterNoise(0.)
	60	,fkNMeanTracklets(5.5)
	61	,fkTrackLikelihood(-15.)
	62	,fNumberOfConfigs(3)
	63	,fFlags(0)
	64	,fRawStreamVersion("DEFAULT")
	65	,fMinMaxCutSigma(4.)
	66	,fMinLeftRightCutSigma(8.)
	67	,fClusMaxThresh(4.5)
	68	,fClusSigThresh(3.5)
	69	,fTCnexp(1)
	70	,fRecEveryNTB(1)
	71	,fNumberOfPresamples(0)
	72	,fNumberOfPostsamples(0)
	73	{
	74	//
	75	// Default constructor
	76	//
	77	fSysCovMatrix[0] = 0.; // y direction (1 cm)
	78	fSysCovMatrix[1] = 0.; // z direction (1 cm)
	79	fSysCovMatrix[2] = 0.; // snp
	80	fSysCovMatrix[3] = 0.; // tgl
	81	fSysCovMatrix[4] = 0.; // 1/pt
	82
	83	// Xe tail cancellation parameters
	84	fTCParams[0] = 1.156; // r1
	85	fTCParams[1] = 0.130; // r2
	86	fTCParams[2] = 0.114; // c1
	87	fTCParams[3] = 0.624; // c2
	88	// Ar tail cancellation parameters
	89	fTCParams[4] = 6.; // r1
	90	fTCParams[5] = 0.62; // r2
	91	fTCParams[6] = 0.0087;// c1
	92	fTCParams[7] = 0.07; // c2
	93
	94	memset(fPIDThreshold, 0, AliTRDCalPID::kNMom*sizeof(Double_t));
	95	memset(fStreamLevel, 0, kTRDreconstructionTasks * sizeof(Int_t));
	96
	97	SetPIDmethod(AliTRDPIDResponse::kLQ1D);
	98	SetEightSlices();
	99	SetImproveTracklets();
	100	SetLUT();
	101	SetTailCancelation();
	102	}
	103
	104	//______________________________________________________________
	105	AliTRDrecoParam::AliTRDrecoParam(const AliTRDrecoParam &ref)
	106	:AliDetectorRecoParam(ref)
	107	,fkdNchdy(ref.fkdNchdy)
	108	,fkMaxTheta(ref.fkMaxTheta)
	109	,fkMaxPhi(ref.fkMaxPhi)
	110	,fkRoad0y(ref.fkRoad0y)
	111	,fkRoad0z(ref.fkRoad0z)
	112	,fkRoad1y(ref.fkRoad1y)
	113	,fkRoad1z(ref.fkRoad1z)
	114	,fkRoad2y(ref.fkRoad2y)
	115	,fkRoad2z(ref.fkRoad2z)
	116	,fkPtThreshold(ref.fkPtThreshold)
	117	,fkPlaneQualityThreshold(ref.fkPlaneQualityThreshold)
	118	,fkRoadzMultiplicator(ref.fkRoadzMultiplicator)
	119	,fkFindable(ref.fkFindable)
	120	,fkChi2Z(ref.fkChi2Z)
	121	,fkChi2Y(ref.fkChi2Y)
	122	,fkChi2YSlope(ref.fkChi2YSlope)
	123	,fkChi2ZSlope(ref.fkChi2ZSlope)
	124	,fkChi2YCut(ref.fkChi2YCut)
	125	,fkPhiSlope(ref.fkPhiSlope)
	126	,fkNMeanClusters(ref.fkNMeanClusters)
	127	,fkNSigmaClusters(ref.fkNSigmaClusters)
	128	,fkNClusterNoise(ref.fkNClusterNoise)
	129	,fkNMeanTracklets(ref.fkNMeanTracklets)
	130	,fkTrackLikelihood(ref.fkTrackLikelihood)
	131	,fNumberOfConfigs(ref.fNumberOfConfigs)
	132	,fFlags(ref.fFlags)
	133	,fRawStreamVersion(ref.fRawStreamVersion)
	134	,fMinMaxCutSigma(ref.fMinMaxCutSigma)
	135	,fMinLeftRightCutSigma(ref.fMinLeftRightCutSigma)
	136	,fClusMaxThresh(ref.fClusMaxThresh)
	137	,fClusSigThresh(ref.fClusSigThresh)
	138	,fTCnexp(ref.fTCnexp)
	139	,fRecEveryNTB(ref.fRecEveryNTB)
	140	,fNumberOfPresamples(ref.fNumberOfPresamples)
	141	,fNumberOfPostsamples(ref.fNumberOfPostsamples)
	142	{
	143	//
	144	// Copy constructor
	145	//
	146	memcpy(fSysCovMatrix, ref.fSysCovMatrix, 5*sizeof(Double_t));
	147	memcpy(fTCParams, ref.fTCParams, 8*sizeof(Double_t));
	148	memcpy(fPIDThreshold, ref.fPIDThreshold, AliTRDCalPID::kNMom*sizeof(Double_t));
	149	memcpy(fStreamLevel, ref.fStreamLevel, kTRDreconstructionTasks * sizeof(Int_t));
	150	}
	151
	152	//______________________________________________________________
	153	AliTRDrecoParam& AliTRDrecoParam::operator=(const AliTRDrecoParam &ref)
	154	{
	155	//
	156	// assignment operator
	157	//
	158
	159	if(this == &ref) return *this;
	160	AliDetectorRecoParam::operator=(ref);
	161	fkdNchdy = ref.fkdNchdy;
	162	fkMaxTheta = ref.fkMaxTheta;
	163	fkMaxPhi = ref.fkMaxPhi;
	164	fkRoad0y = ref.fkRoad0y;
	165	fkRoad0z = ref.fkRoad0z;
	166	fkRoad1y = ref.fkRoad1y;
	167	fkRoad1z = ref.fkRoad1z;
	168	fkRoad2y = ref.fkRoad2y;
	169	fkRoad2z = ref.fkRoad2z;
	170	fkPtThreshold = ref.fkPtThreshold;
	171	fkPlaneQualityThreshold= ref.fkPlaneQualityThreshold;
	172	fkRoadzMultiplicator = ref.fkRoadzMultiplicator;
	173	fkFindable = ref.fkFindable;
	174	fkChi2Z = ref.fkChi2Z;
	175	fkChi2Y = ref.fkChi2Y;
	176	fkChi2YSlope = ref.fkChi2YSlope;
	177	fkChi2ZSlope = ref.fkChi2ZSlope;
	178	fkChi2YCut = ref.fkChi2YCut;
	179	fkPhiSlope = ref.fkPhiSlope;
	180	fkNMeanClusters = ref.fkNMeanClusters;
	181	fkNSigmaClusters = ref.fkNSigmaClusters;
	182	fkNClusterNoise = ref.fkNClusterNoise;
	183	fkNMeanTracklets = ref.fkNMeanTracklets;
	184	fkTrackLikelihood = ref.fkTrackLikelihood;
	185	fNumberOfConfigs = ref.fNumberOfConfigs;
	186	fFlags = ref.fFlags;
	187	fRawStreamVersion = ref.fRawStreamVersion;
	188	fMinMaxCutSigma = ref.fMinMaxCutSigma;
	189	fMinLeftRightCutSigma = ref.fMinLeftRightCutSigma;
	190	fClusMaxThresh = ref.fClusMaxThresh;
	191	fClusSigThresh = ref.fClusSigThresh;
	192	fTCnexp = ref.fTCnexp;
	193	fRecEveryNTB = ref.fRecEveryNTB;
	194	fNumberOfPresamples = ref.fNumberOfPresamples;
	195	fNumberOfPostsamples = ref.fNumberOfPostsamples;
	196
	197	memcpy(fSysCovMatrix, ref.fSysCovMatrix, 5*sizeof(Double_t));
	198	memcpy(fTCParams, ref.fTCParams, 8*sizeof(Double_t));
	199	memcpy(fPIDThreshold, ref.fPIDThreshold, AliTRDCalPID::kNMom*sizeof(Double_t));
	200	memcpy(fStreamLevel, ref.fStreamLevel, kTRDreconstructionTasks * sizeof(Int_t));
	201	return *this;
	202	}
	203
	204	//______________________________________________________________
	205	AliTRDrecoParam *AliTRDrecoParam::GetLowFluxParam()
	206	{
	207	//
	208	// Parameters for the low flux environment
	209	//
	210
	211	AliTRDrecoParam *rec = new AliTRDrecoParam();
	212	rec->fkdNchdy = 12.; // pp in TRD
	213	rec->SetVertexConstrained();
	214	rec->SetCheckTimeConsistency();
	215	return rec;
	216
	217	}
	218
	219	//______________________________________________________________
	220	AliTRDrecoParam *AliTRDrecoParam::GetLowFluxHLTParam()
	221	{
	222	//
	223	// Parameters for the high flux environment in HLT
	224	//
	225
	226	AliTRDrecoParam *rec = GetLowFluxParam();
	227	rec->fNumberOfConfigs = 2;
	228	return rec;
	229
	230	}
	231
	232	//______________________________________________________________
	233	AliTRDrecoParam *AliTRDrecoParam::GetHighFluxParam()
	234	{
	235	//
	236	// Parameters for the high flux environment
	237	//
	238
	239	AliTRDrecoParam *rec = new AliTRDrecoParam();
	240	rec->fkdNchdy = 4000.; // PbPb in TRD
	241	rec->SetVertexConstrained();
	242	rec->SetCheckTimeConsistency();
	243	return rec;
	244
	245	}
	246
	247	//______________________________________________________________
	248	AliTRDrecoParam *AliTRDrecoParam::GetHighFluxHLTParam()
	249	{
	250	//
	251	// Parameters for the high flux environment in HLT
	252	//
	253
	254	AliTRDrecoParam *rec = GetHighFluxParam();
	255	rec->fNumberOfConfigs = 1;
	256	return rec;
	257
	258	}
	259
	260	//______________________________________________________________
	261	AliTRDrecoParam *AliTRDrecoParam::GetCosmicTestParam()
	262	{
	263	//
	264	// Parameters for the cosmics data
	265	//
	266
	267	AliTRDrecoParam *par = new AliTRDrecoParam();
	268	par->fSysCovMatrix[0] = 2.; // y direction (1 cm)
	269	par->fSysCovMatrix[1] = 2.; // z direction (1 cm)
	270	par->fkChi2YSlope = 0.11853;
	271	par->fkChi2ZSlope = 0.04527;
	272	par->fkChi2YCut = 1.;
	273	par->fkPhiSlope = 10.; //3.17954;
	274	par->fkMaxTheta = 2.1445;
	275	par->fkMaxPhi = 2.7475;
	276	par->fkNMeanClusters = 12.89;
	277	par->fkNSigmaClusters = 2.095;
	278	par->fkRoadzMultiplicator = 3.;
	279	par->fStreamLevel[kTracker] = 1;
	280	par->SetCheckTimeConsistency();
	281	return par;
	282
	283	}
	284
	285
	286	//______________________________________________________________
	287	Float_t AliTRDrecoParam::GetNClusters() const
	288	{
	289	// Estimate the number of clusters in the TRD detector
	290
	291	Float_t nclusters = (fkNMeanClusters + 2fkNSigmaClusters)fkNMeanTracklets*fkdNchdy;
	292	nclusters *= 1.+fkNClusterNoise;
	293	return nclusters;
	294	}
	295
	296	//______________________________________________________________
	297	void AliTRDrecoParam::SetPIDLQslices(Int_t s)
	298	{
	299	// Setting number of slices used by the PID LQ method s={1, 2}
	300	// If PID NN is set this function will change to PID LQ.
	301
	302	if(IsPIDNeuralNetwork()){
	303	AliWarning("PID set to NN. Changing to LQ.");
	304	SetPIDNeuralNetwork(kFALSE);
	305	}
	306
	307	switch(s){
	308	case 1:
	309	if(TESTBIT(fFlags, kLQ2D)) CLRBIT(fFlags, kLQ2D);
	310	break;
	311	case 2:
	312	SETBIT(fFlags, kLQ2D);
	313	break;
	314	default:
	315	AliWarning(Form("N[%d] PID LQ slices not implemented. Using default 2.", s));
	316	SETBIT(fFlags, kLQ2D);
	317	break;
	318	}
	319	}
	320