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