[u/mrichter/AliRoot.git] / STEER / AliGRPRecoParam.cxx

/**************************************************************************
 * Copyright(c) 2007-2009, 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.                  *
 **************************************************************************/

#include "AliGRPRecoParam.h"

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class with GRP reconstruction parameters                                  //
// Origin: andrea.dainese@lnl.infn.it                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


ClassImp(AliGRPRecoParam)

//_____________________________________________________________________________
AliGRPRecoParam::AliGRPRecoParam() : AliDetectorRecoParam(),
fMostProbablePt(0.350),
fVertexerTracksConstraintITS(kTRUE),
fVertexerTracksConstraintTPC(kTRUE),
fVertexerTracksNCuts(12),
fVertexerTracksITSdcacut(0.1),
fVertexerTracksITSdcacutIter0(0.1),
fVertexerTracksITSmaxd0z0(0.5),
fVertexerTracksITSminCls(5),
fVertexerTracksITSmintrks(1),
fVertexerTracksITSnsigma(3.),
fVertexerTracksITSnindetfitter(100.),
fVertexerTracksITSmaxtgl(1000.), 
fVertexerTracksITSfidR(3.),
fVertexerTracksITSfidZ(30.),
fVertexerTracksITSalgo(1.),
fVertexerTracksITSalgoIter0(4.),
fVertexerTracksTPCdcacut(0.1),
fVertexerTracksTPCdcacutIter0(1.0),
fVertexerTracksTPCmaxd0z0(5.),
fVertexerTracksTPCminCls(10),
fVertexerTracksTPCmintrks(1),
fVertexerTracksTPCnsigma(3.),
fVertexerTracksTPCnindetfitter(0.1),
fVertexerTracksTPCmaxtgl(1.5), 
fVertexerTracksTPCfidR(3.),
fVertexerTracksTPCfidZ(30.),
fVertexerTracksTPCalgo(1.),
fVertexerTracksTPCalgoIter0(4.),
fVertexerV0NCuts(7),
fVertexerV0Chi2max(33.),
fVertexerV0DNmin(0.05),
fVertexerV0DPmin(0.05),
fVertexerV0DCAmax(1.5),
fVertexerV0CPAmin(0.9),
fVertexerV0Rmin(0.2),
fVertexerV0Rmax(200.),
fVertexerCascadeNCuts(8),
fVertexerCascadeChi2max(33.),
fVertexerCascadeDV0min(0.01),
fVertexerCascadeMassWin(0.008),
fVertexerCascadeDBachMin(0.01),
fVertexerCascadeDCAmax(2.0),
fVertexerCascadeCPAmin(0.98),
fVertexerCascadeRmin(0.2),
fVertexerCascadeRmax(100.)
{
  //
  // constructor
  //
  SetName("GRP");
  SetTitle("GRP");
}

//_____________________________________________________________________________
AliGRPRecoParam::~AliGRPRecoParam() 
{
  //
  // destructor
  //  
}

AliGRPRecoParam::AliGRPRecoParam(const AliGRPRecoParam& par) :
  AliDetectorRecoParam(par),
  fMostProbablePt(par.fMostProbablePt),
  fVertexerTracksConstraintITS(par.fVertexerTracksConstraintITS),
  fVertexerTracksConstraintTPC(par.fVertexerTracksConstraintTPC),
  fVertexerTracksNCuts(par.fVertexerTracksNCuts),
  fVertexerTracksITSdcacut(par.fVertexerTracksITSdcacut),
  fVertexerTracksITSdcacutIter0(par.fVertexerTracksITSdcacutIter0),
  fVertexerTracksITSmaxd0z0(par.fVertexerTracksITSmaxd0z0),
  fVertexerTracksITSminCls(par.fVertexerTracksITSminCls),
  fVertexerTracksITSmintrks(par.fVertexerTracksITSmintrks),
  fVertexerTracksITSnsigma(par.fVertexerTracksITSnsigma),
  fVertexerTracksITSnindetfitter(par.fVertexerTracksITSnindetfitter),
  fVertexerTracksITSmaxtgl(par.fVertexerTracksITSmaxtgl), 
  fVertexerTracksITSfidR(par.fVertexerTracksITSfidR),
  fVertexerTracksITSfidZ(par.fVertexerTracksITSfidZ),
  fVertexerTracksITSalgo(par.fVertexerTracksITSalgo),
  fVertexerTracksITSalgoIter0(par.fVertexerTracksITSalgoIter0),
  fVertexerTracksTPCdcacut(par.fVertexerTracksTPCdcacut),
  fVertexerTracksTPCdcacutIter0(par.fVertexerTracksTPCdcacutIter0),
  fVertexerTracksTPCmaxd0z0(par.fVertexerTracksTPCmaxd0z0),
  fVertexerTracksTPCminCls(par.fVertexerTracksTPCminCls),
  fVertexerTracksTPCmintrks(par.fVertexerTracksTPCmintrks),
  fVertexerTracksTPCnsigma(par.fVertexerTracksTPCnsigma),
  fVertexerTracksTPCnindetfitter(par.fVertexerTracksTPCnindetfitter),
  fVertexerTracksTPCmaxtgl(par.fVertexerTracksTPCmaxtgl), 
  fVertexerTracksTPCfidR(par.fVertexerTracksTPCfidR),
  fVertexerTracksTPCfidZ(par.fVertexerTracksTPCfidZ),
  fVertexerTracksTPCalgo(par.fVertexerTracksTPCalgo),
  fVertexerTracksTPCalgoIter0(par.fVertexerTracksTPCalgoIter0),
  fVertexerV0NCuts(par.fVertexerV0NCuts),
  fVertexerV0Chi2max(par.fVertexerV0Chi2max),
  fVertexerV0DNmin(par.fVertexerV0DNmin),
  fVertexerV0DPmin(par.fVertexerV0DPmin),
  fVertexerV0DCAmax(par.fVertexerV0DCAmax),
  fVertexerV0CPAmin(par.fVertexerV0CPAmin),
  fVertexerV0Rmin(par.fVertexerV0Rmin),
  fVertexerV0Rmax(par.fVertexerV0Rmax),
  fVertexerCascadeNCuts(par.fVertexerCascadeNCuts),
  fVertexerCascadeChi2max(par.fVertexerCascadeChi2max),
  fVertexerCascadeDV0min(par.fVertexerCascadeDV0min),
  fVertexerCascadeMassWin(par.fVertexerCascadeMassWin),
  fVertexerCascadeDBachMin(par.fVertexerCascadeDBachMin),
  fVertexerCascadeDCAmax(par.fVertexerCascadeDCAmax),
  fVertexerCascadeCPAmin(par.fVertexerCascadeCPAmin),
  fVertexerCascadeRmin(par.fVertexerCascadeRmin),
  fVertexerCascadeRmax(par.fVertexerCascadeRmax)
{
  // copy constructor
}

//_____________________________________________________________________________
AliGRPRecoParam& AliGRPRecoParam::operator = (const AliGRPRecoParam& par)
{
  // assignment operator

  if(&par == this) return *this;

  this->~AliGRPRecoParam();
  new(this) AliGRPRecoParam(par);
  return *this;
}

//_____________________________________________________________________________
AliGRPRecoParam *AliGRPRecoParam::GetHighFluxParam() 
{
  //
  // make default reconstruction  parameters for high flux env.
  //
  AliGRPRecoParam *param = new AliGRPRecoParam();

  // to speed up the vertexing in PbPb
  param->fVertexerTracksITSalgoIter0 = 1.;
  param->fVertexerTracksTPCalgoIter0 = 1.;

  // tighter selections for V0s
  param->fVertexerV0Chi2max = 33.;
  param->fVertexerV0DNmin   = 0.1;
  param->fVertexerV0DPmin   = 0.1;
  param->fVertexerV0DCAmax  = 1.0;
  param->fVertexerV0CPAmin  = 0.998;
  param->fVertexerV0Rmin    = 0.9;
  param->fVertexerV0Rmax    = 100.;

  // tighter selections for Cascades
  param->fVertexerCascadeChi2max  = 33.; 
  param->fVertexerCascadeDV0min   = 0.05;  
  param->fVertexerCascadeMassWin  = 0.008; 
  param->fVertexerCascadeDBachMin = 0.030;
  param->fVertexerCascadeDCAmax   = 0.3;  
  param->fVertexerCascadeCPAmin   = 0.999;  
  param->fVertexerCascadeRmin     = 0.9;    
  param->fVertexerCascadeRmax     = 100.;    

  return param;
}
//_____________________________________________________________________________
AliGRPRecoParam *AliGRPRecoParam::GetLowFluxParam() 
{
  //
  // make default reconstruction  parameters for low  flux env.
  //
  AliGRPRecoParam *param = new AliGRPRecoParam();

  return param;
}
//_____________________________________________________________________________
AliGRPRecoParam *AliGRPRecoParam::GetCosmicTestParam() 
{
  //
  // make default reconstruction  parameters for cosmics env.
  //
  AliGRPRecoParam *param = new AliGRPRecoParam();

  param->SetVertexerTracksConstraintITS(kFALSE);
  param->SetVertexerTracksConstraintTPC(kFALSE);
  param->SetMostProbablePt(3.0);

  return param;
}
//_____________________________________________________________________________
void AliGRPRecoParam::GetVertexerTracksCuts(Int_t mode,Double_t *cuts) const {
  //
  // get cuts for ITS (0) or TPC (1) mode
  //
  if(mode==1) {
    cuts[0] = fVertexerTracksTPCdcacut;
    cuts[1] = fVertexerTracksTPCdcacutIter0;
    cuts[2] = fVertexerTracksTPCmaxd0z0;
    cuts[3] = fVertexerTracksTPCminCls;
    cuts[4] = fVertexerTracksTPCmintrks;
    cuts[5] = fVertexerTracksTPCnsigma;
    cuts[6] = fVertexerTracksTPCnindetfitter;
    cuts[7] = fVertexerTracksTPCmaxtgl; 
    cuts[8] = fVertexerTracksTPCfidR;
    cuts[9] = fVertexerTracksTPCfidZ;
    cuts[10]= fVertexerTracksTPCalgo;
    cuts[11]= fVertexerTracksTPCalgoIter0;
  } else {
    cuts[0] = fVertexerTracksITSdcacut;
    cuts[1] = fVertexerTracksITSdcacutIter0;
    cuts[2] = fVertexerTracksITSmaxd0z0;
    cuts[3] = fVertexerTracksITSminCls;
    cuts[4] = fVertexerTracksITSmintrks;
    cuts[5] = fVertexerTracksITSnsigma;
    cuts[6] = fVertexerTracksITSnindetfitter;
    cuts[7] = fVertexerTracksITSmaxtgl; 
    cuts[8] = fVertexerTracksITSfidR;
    cuts[9] = fVertexerTracksITSfidZ;
    cuts[10]= fVertexerTracksITSalgo;
    cuts[11]= fVertexerTracksITSalgoIter0;
  }

  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::SetVertexerTracksCuts(Int_t mode,Int_t ncuts,Double_t cuts[12]) {
  //
  // set cuts for ITS (0) or TPC (1) mode
  //
  if(ncuts!=fVertexerTracksNCuts) {
    printf("AliGRPRecoParam: Number of AliVertexerTracks cuts is %d\n",fVertexerTracksNCuts);
    return;
  }

  if(mode==1) {
    fVertexerTracksTPCdcacut = cuts[0];
    fVertexerTracksTPCdcacutIter0 = cuts[1];
    fVertexerTracksTPCmaxd0z0 = cuts[2];
    fVertexerTracksTPCminCls = cuts[3];
    fVertexerTracksTPCmintrks = cuts[4];
    fVertexerTracksTPCnsigma = cuts[5];
    fVertexerTracksTPCnindetfitter = cuts[6];
    fVertexerTracksTPCmaxtgl = cuts[7]; 
    fVertexerTracksTPCfidR = cuts[8];
    fVertexerTracksTPCfidZ = cuts[9];
    fVertexerTracksTPCalgo = cuts[10];
    fVertexerTracksTPCalgoIter0 = cuts[11];
  } else {
    fVertexerTracksITSdcacut = cuts[0];
    fVertexerTracksITSdcacutIter0 = cuts[1];
    fVertexerTracksITSmaxd0z0 = cuts[2];
    fVertexerTracksITSminCls = cuts[3];
    fVertexerTracksITSmintrks = cuts[4];
    fVertexerTracksITSnsigma = cuts[5];
    fVertexerTracksITSnindetfitter = cuts[6];
    fVertexerTracksITSmaxtgl = cuts[7]; 
    fVertexerTracksITSfidR = cuts[8];
    fVertexerTracksITSfidZ = cuts[9];
    fVertexerTracksITSalgo = cuts[10];
    fVertexerTracksITSalgoIter0 = cuts[11];
  }

  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::GetVertexerV0Cuts(Double_t *cuts) const {
  //
  // get cuts for AliV0vertexer
  //
  cuts[0] = fVertexerV0Chi2max;
  cuts[1] = fVertexerV0DNmin;
  cuts[2] = fVertexerV0DPmin;
  cuts[3] = fVertexerV0DCAmax;
  cuts[4] = fVertexerV0CPAmin;
  cuts[5] = fVertexerV0Rmin;
  cuts[6] = fVertexerV0Rmax;
  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::SetVertexerV0Cuts(Int_t ncuts,Double_t cuts[7]) {
  //
  // set cuts for AliV0vertexer
  //
  if(ncuts!=fVertexerV0NCuts) {
    printf("AliGRPRecoParam: Number of AliV0vertexer cuts is %d\n",fVertexerV0NCuts);
    return;
  }
  fVertexerV0Chi2max = cuts[0];
  fVertexerV0DNmin   = cuts[1];
  fVertexerV0DPmin   = cuts[2];
  fVertexerV0DCAmax  = cuts[3];
  fVertexerV0CPAmin  = cuts[4];
  fVertexerV0Rmin    = cuts[5];
  fVertexerV0Rmax    = cuts[6];
  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::GetVertexerCascadeCuts(Double_t *cuts) const {
  //
  // get cuts for AliCascadevertexer
  //
  cuts[0] = fVertexerCascadeChi2max;
  cuts[1] = fVertexerCascadeDV0min;
  cuts[2] = fVertexerCascadeMassWin;
  cuts[3] = fVertexerCascadeDBachMin;
  cuts[4] = fVertexerCascadeDCAmax;
  cuts[5] = fVertexerCascadeCPAmin;
  cuts[6] = fVertexerCascadeRmin;
  cuts[7] = fVertexerCascadeRmax;
  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::SetVertexerCascadeCuts(Int_t ncuts,Double_t cuts[8]) {
  //
  // set cuts for AliCascadeVertexer
  //
  if(ncuts!=fVertexerCascadeNCuts) {
    printf("AliGRPRecoParam: Number of AliCascadeVertexer cuts is %d\n",fVertexerCascadeNCuts);
    return;
  }
  fVertexerCascadeChi2max  = cuts[0];
  fVertexerCascadeDV0min   = cuts[1];
  fVertexerCascadeMassWin  = cuts[2];
  fVertexerCascadeDBachMin = cuts[3];
  fVertexerCascadeDCAmax   = cuts[4];
  fVertexerCascadeCPAmin   = cuts[5];
  fVertexerCascadeRmin     = cuts[6];
  fVertexerCascadeRmax     = cuts[7];
  return;
}
Commit	Line	Data
a00021a7	1	/**************************************************************************
	2	* Copyright(c) 2007-2009, 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	#include "AliGRPRecoParam.h"
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// Class with GRP reconstruction parameters //
	21	// Origin: andrea.dainese@lnl.infn.it //
	22	// //
	23	///////////////////////////////////////////////////////////////////////////////
	24
	25
	26
	27	ClassImp(AliGRPRecoParam)
	28
	29	//_____________________________________________________________________________
	30	AliGRPRecoParam::AliGRPRecoParam() : AliDetectorRecoParam(),
71f6cda4	31	fMostProbablePt(0.350),
f2a195c1	32	fVertexerTracksConstraintITS(kTRUE),
f2a195c1	33	fVertexerTracksConstraintTPC(kTRUE),
d4bb174f	34	fVertexerTracksNCuts(12),
a00021a7	35	fVertexerTracksITSdcacut(0.1),
	36	fVertexerTracksITSdcacutIter0(0.1),
	37	fVertexerTracksITSmaxd0z0(0.5),
	38	fVertexerTracksITSminCls(5),
	39	fVertexerTracksITSmintrks(1),
	40	fVertexerTracksITSnsigma(3.),
	41	fVertexerTracksITSnindetfitter(100.),
	42	fVertexerTracksITSmaxtgl(1000.),
	43	fVertexerTracksITSfidR(3.),
	44	fVertexerTracksITSfidZ(30.),
8c75f668	45	fVertexerTracksITSalgo(1.),
8c75f668	46	fVertexerTracksITSalgoIter0(4.),
a00021a7	47	fVertexerTracksTPCdcacut(0.1),
	48	fVertexerTracksTPCdcacutIter0(1.0),
	49	fVertexerTracksTPCmaxd0z0(5.),
	50	fVertexerTracksTPCminCls(10),
	51	fVertexerTracksTPCmintrks(1),
	52	fVertexerTracksTPCnsigma(3.),
	53	fVertexerTracksTPCnindetfitter(0.1),
	54	fVertexerTracksTPCmaxtgl(1.5),
	55	fVertexerTracksTPCfidR(3.),
8c75f668	56	fVertexerTracksTPCfidZ(30.),
8c75f668	57	fVertexerTracksTPCalgo(1.),
61a14552	58	fVertexerTracksTPCalgoIter0(4.),
	59	fVertexerV0NCuts(7),
	60	fVertexerV0Chi2max(33.),
	61	fVertexerV0DNmin(0.05),
	62	fVertexerV0DPmin(0.05),
	63	fVertexerV0DCAmax(1.5),
	64	fVertexerV0CPAmin(0.9),
	65	fVertexerV0Rmin(0.2),
	66	fVertexerV0Rmax(200.),
	67	fVertexerCascadeNCuts(8),
	68	fVertexerCascadeChi2max(33.),
	69	fVertexerCascadeDV0min(0.01),
	70	fVertexerCascadeMassWin(0.008),
	71	fVertexerCascadeDBachMin(0.01),
	72	fVertexerCascadeDCAmax(2.0),
	73	fVertexerCascadeCPAmin(0.98),
	74	fVertexerCascadeRmin(0.2),
	75	fVertexerCascadeRmax(100.)
a00021a7	76	{
	77	//
	78	// constructor
	79	//
	80	SetName("GRP");
	81	SetTitle("GRP");
	82	}
	83
	84	//_____________________________________________________________________________
	85	AliGRPRecoParam::~AliGRPRecoParam()
	86	{
	87	//
	88	// destructor
	89	//
	90	}
	91
	92	AliGRPRecoParam::AliGRPRecoParam(const AliGRPRecoParam& par) :
	93	AliDetectorRecoParam(par),
71f6cda4	94	fMostProbablePt(par.fMostProbablePt),
f2a195c1	95	fVertexerTracksConstraintITS(par.fVertexerTracksConstraintITS),
f2a195c1	96	fVertexerTracksConstraintTPC(par.fVertexerTracksConstraintTPC),
a00021a7	97	fVertexerTracksNCuts(par.fVertexerTracksNCuts),
	98	fVertexerTracksITSdcacut(par.fVertexerTracksITSdcacut),
	99	fVertexerTracksITSdcacutIter0(par.fVertexerTracksITSdcacutIter0),
	100	fVertexerTracksITSmaxd0z0(par.fVertexerTracksITSmaxd0z0),
	101	fVertexerTracksITSminCls(par.fVertexerTracksITSminCls),
	102	fVertexerTracksITSmintrks(par.fVertexerTracksITSmintrks),
	103	fVertexerTracksITSnsigma(par.fVertexerTracksITSnsigma),
	104	fVertexerTracksITSnindetfitter(par.fVertexerTracksITSnindetfitter),
	105	fVertexerTracksITSmaxtgl(par.fVertexerTracksITSmaxtgl),
	106	fVertexerTracksITSfidR(par.fVertexerTracksITSfidR),
	107	fVertexerTracksITSfidZ(par.fVertexerTracksITSfidZ),
8c75f668	108	fVertexerTracksITSalgo(par.fVertexerTracksITSalgo),
8c75f668	109	fVertexerTracksITSalgoIter0(par.fVertexerTracksITSalgoIter0),
a00021a7	110	fVertexerTracksTPCdcacut(par.fVertexerTracksTPCdcacut),
	111	fVertexerTracksTPCdcacutIter0(par.fVertexerTracksTPCdcacutIter0),
	112	fVertexerTracksTPCmaxd0z0(par.fVertexerTracksTPCmaxd0z0),
	113	fVertexerTracksTPCminCls(par.fVertexerTracksTPCminCls),
	114	fVertexerTracksTPCmintrks(par.fVertexerTracksTPCmintrks),
	115	fVertexerTracksTPCnsigma(par.fVertexerTracksTPCnsigma),
	116	fVertexerTracksTPCnindetfitter(par.fVertexerTracksTPCnindetfitter),
	117	fVertexerTracksTPCmaxtgl(par.fVertexerTracksTPCmaxtgl),
	118	fVertexerTracksTPCfidR(par.fVertexerTracksTPCfidR),
8c75f668	119	fVertexerTracksTPCfidZ(par.fVertexerTracksTPCfidZ),
8c75f668	120	fVertexerTracksTPCalgo(par.fVertexerTracksTPCalgo),
61a14552	121	fVertexerTracksTPCalgoIter0(par.fVertexerTracksTPCalgoIter0),
	122	fVertexerV0NCuts(par.fVertexerV0NCuts),
	123	fVertexerV0Chi2max(par.fVertexerV0Chi2max),
	124	fVertexerV0DNmin(par.fVertexerV0DNmin),
	125	fVertexerV0DPmin(par.fVertexerV0DPmin),
	126	fVertexerV0DCAmax(par.fVertexerV0DCAmax),
	127	fVertexerV0CPAmin(par.fVertexerV0CPAmin),
	128	fVertexerV0Rmin(par.fVertexerV0Rmin),
	129	fVertexerV0Rmax(par.fVertexerV0Rmax),
	130	fVertexerCascadeNCuts(par.fVertexerCascadeNCuts),
	131	fVertexerCascadeChi2max(par.fVertexerCascadeChi2max),
	132	fVertexerCascadeDV0min(par.fVertexerCascadeDV0min),
	133	fVertexerCascadeMassWin(par.fVertexerCascadeMassWin),
	134	fVertexerCascadeDBachMin(par.fVertexerCascadeDBachMin),
	135	fVertexerCascadeDCAmax(par.fVertexerCascadeDCAmax),
	136	fVertexerCascadeCPAmin(par.fVertexerCascadeCPAmin),
	137	fVertexerCascadeRmin(par.fVertexerCascadeRmin),
	138	fVertexerCascadeRmax(par.fVertexerCascadeRmax)
a00021a7	139	{
	140	// copy constructor
	141	}
	142
	143	//_____________________________________________________________________________
	144	AliGRPRecoParam& AliGRPRecoParam::operator = (const AliGRPRecoParam& par)
	145	{
	146	// assignment operator
	147
	148	if(&par == this) return *this;
	149
	150	this->~AliGRPRecoParam();
	151	new(this) AliGRPRecoParam(par);
	152	return *this;
	153	}
	154
	155	//_____________________________________________________________________________
	156	AliGRPRecoParam *AliGRPRecoParam::GetHighFluxParam()
	157	{
	158	//
61a14552	159	// make default reconstruction parameters for high flux env.
a00021a7	160	//
	161	AliGRPRecoParam *param = new AliGRPRecoParam();
	162
8c75f668	163	// to speed up the vertexing in PbPb
	164	param->fVertexerTracksITSalgoIter0 = 1.;
	165	param->fVertexerTracksTPCalgoIter0 = 1.;
	166
61a14552	167	// tighter selections for V0s
	168	param->fVertexerV0Chi2max = 33.;
	169	param->fVertexerV0DNmin = 0.1;
	170	param->fVertexerV0DPmin = 0.1;
5e1dcac5	171	param->fVertexerV0DCAmax = 1.0;
5e1dcac5	172	param->fVertexerV0CPAmin = 0.998;
61a14552	173	param->fVertexerV0Rmin = 0.9;
	174	param->fVertexerV0Rmax = 100.;
	175
	176	// tighter selections for Cascades
	177	param->fVertexerCascadeChi2max = 33.;
	178	param->fVertexerCascadeDV0min = 0.05;
	179	param->fVertexerCascadeMassWin = 0.008;
5e1dcac5	180	param->fVertexerCascadeDBachMin = 0.030;
	181	param->fVertexerCascadeDCAmax = 0.3;
	182	param->fVertexerCascadeCPAmin = 0.999;
61a14552	183	param->fVertexerCascadeRmin = 0.9;
	184	param->fVertexerCascadeRmax = 100.;
	185
a00021a7	186	return param;
	187	}
	188	//_____________________________________________________________________________
	189	AliGRPRecoParam *AliGRPRecoParam::GetLowFluxParam()
	190	{
	191	//
	192	// make default reconstruction parameters for low flux env.
	193	//
	194	AliGRPRecoParam *param = new AliGRPRecoParam();
	195
	196	return param;
	197	}
	198	//_____________________________________________________________________________
f2a195c1	199	AliGRPRecoParam *AliGRPRecoParam::GetCosmicTestParam()
	200	{
	201	//
	202	// make default reconstruction parameters for cosmics env.
	203	//
	204	AliGRPRecoParam *param = new AliGRPRecoParam();
	205
b5f9d03a	206	param->SetVertexerTracksConstraintITS(kFALSE);
	207	param->SetVertexerTracksConstraintTPC(kFALSE);
	208	param->SetMostProbablePt(3.0);
	209
f2a195c1	210	return param;
	211	}
	212	//_____________________________________________________________________________
a00021a7	213	void AliGRPRecoParam::GetVertexerTracksCuts(Int_t mode,Double_t *cuts) const {
	214	//
	215	// get cuts for ITS (0) or TPC (1) mode
	216	//
	217	if(mode==1) {
	218	cuts[0] = fVertexerTracksTPCdcacut;
	219	cuts[1] = fVertexerTracksTPCdcacutIter0;
	220	cuts[2] = fVertexerTracksTPCmaxd0z0;
	221	cuts[3] = fVertexerTracksTPCminCls;
	222	cuts[4] = fVertexerTracksTPCmintrks;
	223	cuts[5] = fVertexerTracksTPCnsigma;
	224	cuts[6] = fVertexerTracksTPCnindetfitter;
	225	cuts[7] = fVertexerTracksTPCmaxtgl;
	226	cuts[8] = fVertexerTracksTPCfidR;
	227	cuts[9] = fVertexerTracksTPCfidZ;
8c75f668	228	cuts[10]= fVertexerTracksTPCalgo;
8c75f668	229	cuts[11]= fVertexerTracksTPCalgoIter0;
a00021a7	230	} else {
	231	cuts[0] = fVertexerTracksITSdcacut;
	232	cuts[1] = fVertexerTracksITSdcacutIter0;
	233	cuts[2] = fVertexerTracksITSmaxd0z0;
	234	cuts[3] = fVertexerTracksITSminCls;
	235	cuts[4] = fVertexerTracksITSmintrks;
	236	cuts[5] = fVertexerTracksITSnsigma;
	237	cuts[6] = fVertexerTracksITSnindetfitter;
	238	cuts[7] = fVertexerTracksITSmaxtgl;
	239	cuts[8] = fVertexerTracksITSfidR;
	240	cuts[9] = fVertexerTracksITSfidZ;
8c75f668	241	cuts[10]= fVertexerTracksITSalgo;
8c75f668	242	cuts[11]= fVertexerTracksITSalgoIter0;
a00021a7	243	}
	244
	245	return;
	246	}
	247	//_____________________________________________________________________________
8c75f668	248	void AliGRPRecoParam::SetVertexerTracksCuts(Int_t mode,Int_t ncuts,Double_t cuts[12]) {
a00021a7	249	//
	250	// set cuts for ITS (0) or TPC (1) mode
	251	//
	252	if(ncuts!=fVertexerTracksNCuts) {
	253	printf("AliGRPRecoParam: Number of AliVertexerTracks cuts is %d\n",fVertexerTracksNCuts);
	254	return;
	255	}
	256
	257	if(mode==1) {
	258	fVertexerTracksTPCdcacut = cuts[0];
	259	fVertexerTracksTPCdcacutIter0 = cuts[1];
	260	fVertexerTracksTPCmaxd0z0 = cuts[2];
	261	fVertexerTracksTPCminCls = cuts[3];
	262	fVertexerTracksTPCmintrks = cuts[4];
	263	fVertexerTracksTPCnsigma = cuts[5];
	264	fVertexerTracksTPCnindetfitter = cuts[6];
	265	fVertexerTracksTPCmaxtgl = cuts[7];
	266	fVertexerTracksTPCfidR = cuts[8];
	267	fVertexerTracksTPCfidZ = cuts[9];
8c75f668	268	fVertexerTracksTPCalgo = cuts[10];
8c75f668	269	fVertexerTracksTPCalgoIter0 = cuts[11];
a00021a7	270	} else {
	271	fVertexerTracksITSdcacut = cuts[0];
	272	fVertexerTracksITSdcacutIter0 = cuts[1];
	273	fVertexerTracksITSmaxd0z0 = cuts[2];
	274	fVertexerTracksITSminCls = cuts[3];
	275	fVertexerTracksITSmintrks = cuts[4];
	276	fVertexerTracksITSnsigma = cuts[5];
	277	fVertexerTracksITSnindetfitter = cuts[6];
	278	fVertexerTracksITSmaxtgl = cuts[7];
	279	fVertexerTracksITSfidR = cuts[8];
	280	fVertexerTracksITSfidZ = cuts[9];
8c75f668	281	fVertexerTracksITSalgo = cuts[10];
8c75f668	282	fVertexerTracksITSalgoIter0 = cuts[11];
a00021a7	283	}
	284
	285	return;
	286	}
61a14552	287	//_____________________________________________________________________________
	288	void AliGRPRecoParam::GetVertexerV0Cuts(Double_t *cuts) const {
	289	//
	290	// get cuts for AliV0vertexer
	291	//
	292	cuts[0] = fVertexerV0Chi2max;
	293	cuts[1] = fVertexerV0DNmin;
	294	cuts[2] = fVertexerV0DPmin;
	295	cuts[3] = fVertexerV0DCAmax;
	296	cuts[4] = fVertexerV0CPAmin;
	297	cuts[5] = fVertexerV0Rmin;
	298	cuts[6] = fVertexerV0Rmax;
	299	return;
	300	}
	301	//_____________________________________________________________________________
	302	void AliGRPRecoParam::SetVertexerV0Cuts(Int_t ncuts,Double_t cuts[7]) {
	303	//
	304	// set cuts for AliV0vertexer
	305	//
	306	if(ncuts!=fVertexerV0NCuts) {
	307	printf("AliGRPRecoParam: Number of AliV0vertexer cuts is %d\n",fVertexerV0NCuts);
	308	return;
	309	}
	310	fVertexerV0Chi2max = cuts[0];
	311	fVertexerV0DNmin = cuts[1];
	312	fVertexerV0DPmin = cuts[2];
	313	fVertexerV0DCAmax = cuts[3];
	314	fVertexerV0CPAmin = cuts[4];
	315	fVertexerV0Rmin = cuts[5];
	316	fVertexerV0Rmax = cuts[6];
	317	return;
	318	}
	319	//_____________________________________________________________________________
	320	void AliGRPRecoParam::GetVertexerCascadeCuts(Double_t *cuts) const {
	321	//
	322	// get cuts for AliCascadevertexer
	323	//
	324	cuts[0] = fVertexerCascadeChi2max;
	325	cuts[1] = fVertexerCascadeDV0min;
	326	cuts[2] = fVertexerCascadeMassWin;
	327	cuts[3] = fVertexerCascadeDBachMin;
	328	cuts[4] = fVertexerCascadeDCAmax;
	329	cuts[5] = fVertexerCascadeCPAmin;
	330	cuts[6] = fVertexerCascadeRmin;
	331	cuts[7] = fVertexerCascadeRmax;
	332	return;
	333	}
	334	//_____________________________________________________________________________
	335	void AliGRPRecoParam::SetVertexerCascadeCuts(Int_t ncuts,Double_t cuts[8]) {
	336	//
	337	// set cuts for AliCascadeVertexer
	338	//
	339	if(ncuts!=fVertexerCascadeNCuts) {
	340	printf("AliGRPRecoParam: Number of AliCascadeVertexer cuts is %d\n",fVertexerCascadeNCuts);
	341	return;
	342	}
	343	fVertexerCascadeChi2max = cuts[0];
	344	fVertexerCascadeDV0min = cuts[1];
	345	fVertexerCascadeMassWin = cuts[2];
	346	fVertexerCascadeDBachMin = cuts[3];
	347	fVertexerCascadeDCAmax = cuts[4];
	348	fVertexerCascadeCPAmin = cuts[5];
	349	fVertexerCascadeRmin = cuts[6];
	350	fVertexerCascadeRmax = cuts[7];
351	return;
352	}