[u/mrichter/AliRoot.git] / STEER / 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(24),
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.),
//
fVertexerTracksITSMVTukey2(7.),
fVertexerTracksITSMVSig2Ini(1e3),
fVertexerTracksITSMVMaxSigma2(5.0),
fVertexerTracksITSMVMinSig2Red(0.05),
fVertexerTracksITSMVMinDst(10e-4),
fVertexerTracksITSMVScanStep(2.),
fVertexerTracksITSMVMaxWghNtr(10),
fVertexerTracksITSMVFinalWBinary(1),
fVertexerTracksITSMVBCSpacing(50),
//
fVertexerTracksITSclusterize(0),
fVertexerTracksITSclusterdz(999999.),
fVertexerTracksITSclusternsigmaz(3.),
//
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.),
//
fVertexerTracksTPCMVTukey2(7.),
fVertexerTracksTPCMVSig2Ini(1e3),
fVertexerTracksTPCMVMaxSigma2(5.0),
fVertexerTracksTPCMVMinSig2Red(0.05),
fVertexerTracksTPCMVMinDst(10e-4),
fVertexerTracksTPCMVScanStep(2.),
fVertexerTracksTPCMVMaxWghNtr(10),
fVertexerTracksTPCMVFinalWBinary(1),
fVertexerTracksTPCMVBCSpacing(50),
//
fVertexerTracksTPCclusterize(0),
fVertexerTracksTPCclusterdz(999999.),
fVertexerTracksTPCclusternsigmaz(3.),
//
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),
  //
  fVertexerTracksITSMVTukey2(par.fVertexerTracksITSMVTukey2),
  fVertexerTracksITSMVSig2Ini(par.fVertexerTracksITSMVSig2Ini),
  fVertexerTracksITSMVMaxSigma2(par.fVertexerTracksITSMVMaxSigma2),
  fVertexerTracksITSMVMinSig2Red(par.fVertexerTracksITSMVMinSig2Red),
  fVertexerTracksITSMVMinDst(par.fVertexerTracksITSMVMinDst),
  fVertexerTracksITSMVScanStep(par.fVertexerTracksITSMVScanStep),
  fVertexerTracksITSMVMaxWghNtr(par.fVertexerTracksITSMVMaxWghNtr),
  fVertexerTracksITSMVFinalWBinary(par.fVertexerTracksITSMVFinalWBinary),
  fVertexerTracksITSMVBCSpacing(par.fVertexerTracksITSMVBCSpacing),
  //
  fVertexerTracksITSclusterize(par.fVertexerTracksITSclusterize),
  fVertexerTracksITSclusterdz(par.fVertexerTracksITSclusterdz),
  fVertexerTracksITSclusternsigmaz(par.fVertexerTracksITSclusternsigmaz),
  //
  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),
  //
  fVertexerTracksTPCMVTukey2(par.fVertexerTracksTPCMVTukey2),
  fVertexerTracksTPCMVSig2Ini(par.fVertexerTracksTPCMVSig2Ini),
  fVertexerTracksTPCMVMaxSigma2(par.fVertexerTracksTPCMVMaxSigma2),
  fVertexerTracksTPCMVMinSig2Red(par.fVertexerTracksTPCMVMinSig2Red),
  fVertexerTracksTPCMVMinDst(par.fVertexerTracksTPCMVMinDst),
  fVertexerTracksTPCMVScanStep(par.fVertexerTracksTPCMVScanStep),
  fVertexerTracksTPCMVMaxWghNtr(par.fVertexerTracksTPCMVMaxWghNtr),
  fVertexerTracksTPCMVFinalWBinary(par.fVertexerTracksTPCMVFinalWBinary),
  fVertexerTracksTPCMVBCSpacing(par.fVertexerTracksTPCMVBCSpacing),
  //
  fVertexerTracksTPCclusterize(par.fVertexerTracksTPCclusterize),
  fVertexerTracksTPCclusterdz(par.fVertexerTracksTPCclusterdz),
  fVertexerTracksTPCclusternsigmaz(par.fVertexerTracksTPCclusternsigmaz),
  //
  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, int n) const {
  //
  // get cuts for ITS (0) or TPC (1) mode
  //
  if(mode==1) {
    if (n>0)  cuts[0] = fVertexerTracksTPCdcacut;
    if (n>1)  cuts[1] = fVertexerTracksTPCdcacutIter0;
    if (n>2)  cuts[2] = fVertexerTracksTPCmaxd0z0;
    if (n>3)  cuts[3] = fVertexerTracksTPCminCls;
    if (n>4)  cuts[4] = fVertexerTracksTPCmintrks;
    if (n>5)  cuts[5] = fVertexerTracksTPCnsigma;
    if (n>6)  cuts[6] = fVertexerTracksTPCnindetfitter;
    if (n>7)  cuts[7] = fVertexerTracksTPCmaxtgl; 
    if (n>8)  cuts[8] = fVertexerTracksTPCfidR;
    if (n>9)  cuts[9] = fVertexerTracksTPCfidZ;
    if (n>10) cuts[10]= fVertexerTracksTPCalgo;
    if (n>11) cuts[11]= fVertexerTracksTPCalgoIter0;
    //
    if (n>12)  cuts[12]= fVertexerTracksTPCMVTukey2;
    if (n>13)  cuts[13]= fVertexerTracksTPCMVSig2Ini;
    if (n>14)  cuts[14]= fVertexerTracksTPCMVMaxSigma2;
    if (n>15)  cuts[15]= fVertexerTracksTPCMVMinSig2Red;
    if (n>16)  cuts[16]= fVertexerTracksTPCMVMinDst;
    if (n>17)  cuts[17]= fVertexerTracksTPCMVScanStep;
    if (n>18)  cuts[18]= fVertexerTracksTPCMVMaxWghNtr;
    if (n>19)  cuts[19]= fVertexerTracksTPCMVFinalWBinary;
    if (n>20)  cuts[20]= fVertexerTracksTPCMVBCSpacing;
    //
    if (n>21)  cuts[21]= fVertexerTracksTPCclusterize;
    if (n>22)  cuts[22]= fVertexerTracksTPCclusterdz;
    if (n>23)  cuts[23]= fVertexerTracksTPCclusternsigmaz;
  } else {
    if (n>0 ) cuts[0] = fVertexerTracksITSdcacut;
    if (n>1 ) cuts[1] = fVertexerTracksITSdcacutIter0;
    if (n>2 ) cuts[2] = fVertexerTracksITSmaxd0z0;
    if (n>3 ) cuts[3] = fVertexerTracksITSminCls;
    if (n>4 ) cuts[4] = fVertexerTracksITSmintrks;
    if (n>5 ) cuts[5] = fVertexerTracksITSnsigma;
    if (n>6 ) cuts[6] = fVertexerTracksITSnindetfitter;
    if (n>7 ) cuts[7] = fVertexerTracksITSmaxtgl; 
    if (n>8 ) cuts[8] = fVertexerTracksITSfidR;
    if (n>9 ) cuts[9] = fVertexerTracksITSfidZ;
    if (n>10) cuts[10]= fVertexerTracksITSalgo;
    if (n>11) cuts[11]= fVertexerTracksITSalgoIter0;
    //
    if (n>12) cuts[12]= fVertexerTracksITSMVTukey2;
    if (n>13) cuts[13]= fVertexerTracksITSMVSig2Ini;
    if (n>14) cuts[14]= fVertexerTracksITSMVMaxSigma2;
    if (n>15) cuts[15]= fVertexerTracksITSMVMinSig2Red;
    if (n>16) cuts[16]= fVertexerTracksITSMVMinDst;
    if (n>17) cuts[17]= fVertexerTracksITSMVScanStep;
    if (n>18) cuts[18]= fVertexerTracksITSMVMaxWghNtr;
    if (n>19) cuts[19]= fVertexerTracksITSMVFinalWBinary;
    if (n>20) cuts[20]= fVertexerTracksITSMVBCSpacing;
    //
    if (n>21)  cuts[21]= fVertexerTracksITSclusterize;
    if (n>22)  cuts[22]= fVertexerTracksITSclusterdz;
    if (n>23)  cuts[23]= fVertexerTracksITSclusternsigmaz;
  }

  return;
}
//_____________________________________________________________________________
void AliGRPRecoParam::SetVertexerTracksCuts(Int_t mode,Int_t ncuts,Double_t* cuts) {
  //
  // 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) {
    if (ncuts>0) fVertexerTracksTPCdcacut = cuts[0];
    if (ncuts>1) fVertexerTracksTPCdcacutIter0 = cuts[1];
    if (ncuts>2) fVertexerTracksTPCmaxd0z0 = cuts[2];
    if (ncuts>3) fVertexerTracksTPCminCls = cuts[3];
    if (ncuts>4) fVertexerTracksTPCmintrks = cuts[4];
    if (ncuts>5) fVertexerTracksTPCnsigma = cuts[5];
    if (ncuts>6) fVertexerTracksTPCnindetfitter = cuts[6];
    if (ncuts>7) fVertexerTracksTPCmaxtgl = cuts[7]; 
    if (ncuts>8) fVertexerTracksTPCfidR = cuts[8];
    if (ncuts>9) fVertexerTracksTPCfidZ = cuts[9];
    if (ncuts>10) fVertexerTracksTPCalgo = cuts[10];
    if (ncuts>11) fVertexerTracksTPCalgoIter0 = cuts[11];
    //
    if (ncuts>12) fVertexerTracksTPCMVTukey2       = cuts[12];
    if (ncuts>13) fVertexerTracksTPCMVSig2Ini      = cuts[13];
    if (ncuts>14) fVertexerTracksTPCMVMaxSigma2    = cuts[14];
    if (ncuts>15) fVertexerTracksTPCMVMinSig2Red   = cuts[15];
    if (ncuts>16) fVertexerTracksTPCMVMinDst       = cuts[16];
    if (ncuts>17) fVertexerTracksTPCMVScanStep     = cuts[17];
    if (ncuts>18) fVertexerTracksTPCMVMaxWghNtr    = cuts[18];
    if (ncuts>19) fVertexerTracksTPCMVFinalWBinary = cuts[19];
    if (ncuts>20) fVertexerTracksTPCMVBCSpacing    = cuts[20];
    //
    if (ncuts>21) fVertexerTracksTPCclusterize     = cuts[21];
    if (ncuts>22) fVertexerTracksTPCclusterdz      = cuts[22];
    if (ncuts>23) fVertexerTracksTPCclusternsigmaz = cuts[23];
  } else {
    if (ncuts>0) fVertexerTracksITSdcacut = cuts[0];
    if (ncuts>1) fVertexerTracksITSdcacutIter0 = cuts[1];
    if (ncuts>2) fVertexerTracksITSmaxd0z0 = cuts[2];
    if (ncuts>3) fVertexerTracksITSminCls = cuts[3];
    if (ncuts>4) fVertexerTracksITSmintrks = cuts[4];
    if (ncuts>5) fVertexerTracksITSnsigma = cuts[5];
    if (ncuts>6) fVertexerTracksITSnindetfitter = cuts[6];
    if (ncuts>7) fVertexerTracksITSmaxtgl = cuts[7]; 
    if (ncuts>8) fVertexerTracksITSfidR = cuts[8];
    if (ncuts>9) fVertexerTracksITSfidZ = cuts[9];
    if (ncuts>10) fVertexerTracksITSalgo = cuts[10];
    if (ncuts>11) fVertexerTracksITSalgoIter0 = cuts[11];
    //
    if (ncuts>12) fVertexerTracksITSMVTukey2       = cuts[12];
    if (ncuts>13) fVertexerTracksITSMVSig2Ini      = cuts[13];
    if (ncuts>14) fVertexerTracksITSMVMaxSigma2    = cuts[14];
    if (ncuts>15) fVertexerTracksITSMVMinSig2Red   = cuts[15];
    if (ncuts>16) fVertexerTracksITSMVMinDst       = cuts[16];
    if (ncuts>17) fVertexerTracksITSMVScanStep     = cuts[17];
    if (ncuts>18) fVertexerTracksITSMVMaxWghNtr    = cuts[18];
    if (ncuts>19) fVertexerTracksITSMVFinalWBinary = cuts[19];
    if (ncuts>20) fVertexerTracksITSMVBCSpacing    = cuts[20];
    //
    if (ncuts>21) fVertexerTracksITSclusterize     = cuts[21];
    if (ncuts>22) fVertexerTracksITSclusterdz      = cuts[22];
    if (ncuts>23) fVertexerTracksITSclusternsigmaz = cuts[23];
  }
  //
  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),
7878b3ae	34	fVertexerTracksNCuts(24),
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.),
3f2db92f	47	//
	48	fVertexerTracksITSMVTukey2(7.),
	49	fVertexerTracksITSMVSig2Ini(1e3),
	50	fVertexerTracksITSMVMaxSigma2(5.0),
	51	fVertexerTracksITSMVMinSig2Red(0.05),
	52	fVertexerTracksITSMVMinDst(10e-4),
	53	fVertexerTracksITSMVScanStep(2.),
	54	fVertexerTracksITSMVMaxWghNtr(10),
	55	fVertexerTracksITSMVFinalWBinary(1),
	56	fVertexerTracksITSMVBCSpacing(50),
	57	//
7878b3ae	58	fVertexerTracksITSclusterize(0),
	59	fVertexerTracksITSclusterdz(999999.),
	60	fVertexerTracksITSclusternsigmaz(3.),
	61	//
a00021a7	62	fVertexerTracksTPCdcacut(0.1),
	63	fVertexerTracksTPCdcacutIter0(1.0),
	64	fVertexerTracksTPCmaxd0z0(5.),
	65	fVertexerTracksTPCminCls(10),
	66	fVertexerTracksTPCmintrks(1),
	67	fVertexerTracksTPCnsigma(3.),
	68	fVertexerTracksTPCnindetfitter(0.1),
	69	fVertexerTracksTPCmaxtgl(1.5),
	70	fVertexerTracksTPCfidR(3.),
8c75f668	71	fVertexerTracksTPCfidZ(30.),
8c75f668	72	fVertexerTracksTPCalgo(1.),
61a14552	73	fVertexerTracksTPCalgoIter0(4.),
3f2db92f	74	//
	75	fVertexerTracksTPCMVTukey2(7.),
	76	fVertexerTracksTPCMVSig2Ini(1e3),
	77	fVertexerTracksTPCMVMaxSigma2(5.0),
	78	fVertexerTracksTPCMVMinSig2Red(0.05),
	79	fVertexerTracksTPCMVMinDst(10e-4),
	80	fVertexerTracksTPCMVScanStep(2.),
	81	fVertexerTracksTPCMVMaxWghNtr(10),
	82	fVertexerTracksTPCMVFinalWBinary(1),
	83	fVertexerTracksTPCMVBCSpacing(50),
	84	//
7878b3ae	85	fVertexerTracksTPCclusterize(0),
	86	fVertexerTracksTPCclusterdz(999999.),
	87	fVertexerTracksTPCclusternsigmaz(3.),
	88	//
61a14552	89	fVertexerV0NCuts(7),
	90	fVertexerV0Chi2max(33.),
	91	fVertexerV0DNmin(0.05),
	92	fVertexerV0DPmin(0.05),
	93	fVertexerV0DCAmax(1.5),
	94	fVertexerV0CPAmin(0.9),
	95	fVertexerV0Rmin(0.2),
	96	fVertexerV0Rmax(200.),
	97	fVertexerCascadeNCuts(8),
	98	fVertexerCascadeChi2max(33.),
	99	fVertexerCascadeDV0min(0.01),
	100	fVertexerCascadeMassWin(0.008),
	101	fVertexerCascadeDBachMin(0.01),
	102	fVertexerCascadeDCAmax(2.0),
	103	fVertexerCascadeCPAmin(0.98),
	104	fVertexerCascadeRmin(0.2),
	105	fVertexerCascadeRmax(100.)
a00021a7	106	{
	107	//
	108	// constructor
	109	//
	110	SetName("GRP");
	111	SetTitle("GRP");
	112	}
	113
	114	//_____________________________________________________________________________
	115	AliGRPRecoParam::~AliGRPRecoParam()
	116	{
	117	//
	118	// destructor
	119	//
	120	}
	121
	122	AliGRPRecoParam::AliGRPRecoParam(const AliGRPRecoParam& par) :
	123	AliDetectorRecoParam(par),
71f6cda4	124	fMostProbablePt(par.fMostProbablePt),
f2a195c1	125	fVertexerTracksConstraintITS(par.fVertexerTracksConstraintITS),
f2a195c1	126	fVertexerTracksConstraintTPC(par.fVertexerTracksConstraintTPC),
a00021a7	127	fVertexerTracksNCuts(par.fVertexerTracksNCuts),
	128	fVertexerTracksITSdcacut(par.fVertexerTracksITSdcacut),
	129	fVertexerTracksITSdcacutIter0(par.fVertexerTracksITSdcacutIter0),
	130	fVertexerTracksITSmaxd0z0(par.fVertexerTracksITSmaxd0z0),
	131	fVertexerTracksITSminCls(par.fVertexerTracksITSminCls),
	132	fVertexerTracksITSmintrks(par.fVertexerTracksITSmintrks),
	133	fVertexerTracksITSnsigma(par.fVertexerTracksITSnsigma),
	134	fVertexerTracksITSnindetfitter(par.fVertexerTracksITSnindetfitter),
	135	fVertexerTracksITSmaxtgl(par.fVertexerTracksITSmaxtgl),
	136	fVertexerTracksITSfidR(par.fVertexerTracksITSfidR),
	137	fVertexerTracksITSfidZ(par.fVertexerTracksITSfidZ),
8c75f668	138	fVertexerTracksITSalgo(par.fVertexerTracksITSalgo),
8c75f668	139	fVertexerTracksITSalgoIter0(par.fVertexerTracksITSalgoIter0),
3f2db92f	140	//
	141	fVertexerTracksITSMVTukey2(par.fVertexerTracksITSMVTukey2),
	142	fVertexerTracksITSMVSig2Ini(par.fVertexerTracksITSMVSig2Ini),
	143	fVertexerTracksITSMVMaxSigma2(par.fVertexerTracksITSMVMaxSigma2),
	144	fVertexerTracksITSMVMinSig2Red(par.fVertexerTracksITSMVMinSig2Red),
	145	fVertexerTracksITSMVMinDst(par.fVertexerTracksITSMVMinDst),
	146	fVertexerTracksITSMVScanStep(par.fVertexerTracksITSMVScanStep),
	147	fVertexerTracksITSMVMaxWghNtr(par.fVertexerTracksITSMVMaxWghNtr),
	148	fVertexerTracksITSMVFinalWBinary(par.fVertexerTracksITSMVFinalWBinary),
	149	fVertexerTracksITSMVBCSpacing(par.fVertexerTracksITSMVBCSpacing),
	150	//
7878b3ae	151	fVertexerTracksITSclusterize(par.fVertexerTracksITSclusterize),
	152	fVertexerTracksITSclusterdz(par.fVertexerTracksITSclusterdz),
	153	fVertexerTracksITSclusternsigmaz(par.fVertexerTracksITSclusternsigmaz),
	154	//
a00021a7	155	fVertexerTracksTPCdcacut(par.fVertexerTracksTPCdcacut),
	156	fVertexerTracksTPCdcacutIter0(par.fVertexerTracksTPCdcacutIter0),
	157	fVertexerTracksTPCmaxd0z0(par.fVertexerTracksTPCmaxd0z0),
	158	fVertexerTracksTPCminCls(par.fVertexerTracksTPCminCls),
	159	fVertexerTracksTPCmintrks(par.fVertexerTracksTPCmintrks),
	160	fVertexerTracksTPCnsigma(par.fVertexerTracksTPCnsigma),
	161	fVertexerTracksTPCnindetfitter(par.fVertexerTracksTPCnindetfitter),
	162	fVertexerTracksTPCmaxtgl(par.fVertexerTracksTPCmaxtgl),
	163	fVertexerTracksTPCfidR(par.fVertexerTracksTPCfidR),
8c75f668	164	fVertexerTracksTPCfidZ(par.fVertexerTracksTPCfidZ),
8c75f668	165	fVertexerTracksTPCalgo(par.fVertexerTracksTPCalgo),
61a14552	166	fVertexerTracksTPCalgoIter0(par.fVertexerTracksTPCalgoIter0),
3f2db92f	167	//
	168	fVertexerTracksTPCMVTukey2(par.fVertexerTracksTPCMVTukey2),
	169	fVertexerTracksTPCMVSig2Ini(par.fVertexerTracksTPCMVSig2Ini),
	170	fVertexerTracksTPCMVMaxSigma2(par.fVertexerTracksTPCMVMaxSigma2),
	171	fVertexerTracksTPCMVMinSig2Red(par.fVertexerTracksTPCMVMinSig2Red),
	172	fVertexerTracksTPCMVMinDst(par.fVertexerTracksTPCMVMinDst),
	173	fVertexerTracksTPCMVScanStep(par.fVertexerTracksTPCMVScanStep),
	174	fVertexerTracksTPCMVMaxWghNtr(par.fVertexerTracksTPCMVMaxWghNtr),
	175	fVertexerTracksTPCMVFinalWBinary(par.fVertexerTracksTPCMVFinalWBinary),
	176	fVertexerTracksTPCMVBCSpacing(par.fVertexerTracksTPCMVBCSpacing),
	177	//
7878b3ae	178	fVertexerTracksTPCclusterize(par.fVertexerTracksTPCclusterize),
	179	fVertexerTracksTPCclusterdz(par.fVertexerTracksTPCclusterdz),
	180	fVertexerTracksTPCclusternsigmaz(par.fVertexerTracksTPCclusternsigmaz),
	181	//
61a14552	182	fVertexerV0NCuts(par.fVertexerV0NCuts),
	183	fVertexerV0Chi2max(par.fVertexerV0Chi2max),
	184	fVertexerV0DNmin(par.fVertexerV0DNmin),
	185	fVertexerV0DPmin(par.fVertexerV0DPmin),
	186	fVertexerV0DCAmax(par.fVertexerV0DCAmax),
	187	fVertexerV0CPAmin(par.fVertexerV0CPAmin),
	188	fVertexerV0Rmin(par.fVertexerV0Rmin),
	189	fVertexerV0Rmax(par.fVertexerV0Rmax),
	190	fVertexerCascadeNCuts(par.fVertexerCascadeNCuts),
	191	fVertexerCascadeChi2max(par.fVertexerCascadeChi2max),
	192	fVertexerCascadeDV0min(par.fVertexerCascadeDV0min),
	193	fVertexerCascadeMassWin(par.fVertexerCascadeMassWin),
	194	fVertexerCascadeDBachMin(par.fVertexerCascadeDBachMin),
	195	fVertexerCascadeDCAmax(par.fVertexerCascadeDCAmax),
	196	fVertexerCascadeCPAmin(par.fVertexerCascadeCPAmin),
	197	fVertexerCascadeRmin(par.fVertexerCascadeRmin),
	198	fVertexerCascadeRmax(par.fVertexerCascadeRmax)
a00021a7	199	{
	200	// copy constructor
	201	}
	202
	203	//_____________________________________________________________________________
	204	AliGRPRecoParam& AliGRPRecoParam::operator = (const AliGRPRecoParam& par)
	205	{
	206	// assignment operator
	207
	208	if(&par == this) return *this;
	209
	210	this->~AliGRPRecoParam();
	211	new(this) AliGRPRecoParam(par);
	212	return *this;
	213	}
	214
	215	//_____________________________________________________________________________
	216	AliGRPRecoParam *AliGRPRecoParam::GetHighFluxParam()
	217	{
	218	//
61a14552	219	// make default reconstruction parameters for high flux env.
a00021a7	220	//
	221	AliGRPRecoParam *param = new AliGRPRecoParam();
	222
8c75f668	223	// to speed up the vertexing in PbPb
	224	param->fVertexerTracksITSalgoIter0 = 1.;
	225	param->fVertexerTracksTPCalgoIter0 = 1.;
	226
61a14552	227	// tighter selections for V0s
	228	param->fVertexerV0Chi2max = 33.;
	229	param->fVertexerV0DNmin = 0.1;
	230	param->fVertexerV0DPmin = 0.1;
5e1dcac5	231	param->fVertexerV0DCAmax = 1.0;
5e1dcac5	232	param->fVertexerV0CPAmin = 0.998;
61a14552	233	param->fVertexerV0Rmin = 0.9;
	234	param->fVertexerV0Rmax = 100.;
	235
	236	// tighter selections for Cascades
	237	param->fVertexerCascadeChi2max = 33.;
	238	param->fVertexerCascadeDV0min = 0.05;
	239	param->fVertexerCascadeMassWin = 0.008;
5e1dcac5	240	param->fVertexerCascadeDBachMin = 0.030;
	241	param->fVertexerCascadeDCAmax = 0.3;
	242	param->fVertexerCascadeCPAmin = 0.999;
61a14552	243	param->fVertexerCascadeRmin = 0.9;
	244	param->fVertexerCascadeRmax = 100.;
	245
a00021a7	246	return param;
	247	}
	248	//_____________________________________________________________________________
	249	AliGRPRecoParam *AliGRPRecoParam::GetLowFluxParam()
	250	{
	251	//
	252	// make default reconstruction parameters for low flux env.
	253	//
	254	AliGRPRecoParam *param = new AliGRPRecoParam();
a00021a7	255	return param;
	256	}
	257	//_____________________________________________________________________________
f2a195c1	258	AliGRPRecoParam *AliGRPRecoParam::GetCosmicTestParam()
	259	{
	260	//
	261	// make default reconstruction parameters for cosmics env.
	262	//
	263	AliGRPRecoParam *param = new AliGRPRecoParam();
	264
b5f9d03a	265	param->SetVertexerTracksConstraintITS(kFALSE);
	266	param->SetVertexerTracksConstraintTPC(kFALSE);
	267	param->SetMostProbablePt(3.0);
	268
f2a195c1	269	return param;
	270	}
	271	//_____________________________________________________________________________
8eaa1a42	272	void AliGRPRecoParam::GetVertexerTracksCuts(Int_t mode,Double_t *cuts, int n) const {
a00021a7	273	//
	274	// get cuts for ITS (0) or TPC (1) mode
	275	//
	276	if(mode==1) {
8eaa1a42	277	if (n>0) cuts[0] = fVertexerTracksTPCdcacut;
	278	if (n>1) cuts[1] = fVertexerTracksTPCdcacutIter0;
	279	if (n>2) cuts[2] = fVertexerTracksTPCmaxd0z0;
	280	if (n>3) cuts[3] = fVertexerTracksTPCminCls;
	281	if (n>4) cuts[4] = fVertexerTracksTPCmintrks;
	282	if (n>5) cuts[5] = fVertexerTracksTPCnsigma;
	283	if (n>6) cuts[6] = fVertexerTracksTPCnindetfitter;
	284	if (n>7) cuts[7] = fVertexerTracksTPCmaxtgl;
	285	if (n>8) cuts[8] = fVertexerTracksTPCfidR;
	286	if (n>9) cuts[9] = fVertexerTracksTPCfidZ;
	287	if (n>10) cuts[10]= fVertexerTracksTPCalgo;
	288	if (n>11) cuts[11]= fVertexerTracksTPCalgoIter0;
3f2db92f	289	//
8eaa1a42	290	if (n>12) cuts[12]= fVertexerTracksTPCMVTukey2;
	291	if (n>13) cuts[13]= fVertexerTracksTPCMVSig2Ini;
	292	if (n>14) cuts[14]= fVertexerTracksTPCMVMaxSigma2;
	293	if (n>15) cuts[15]= fVertexerTracksTPCMVMinSig2Red;
	294	if (n>16) cuts[16]= fVertexerTracksTPCMVMinDst;
	295	if (n>17) cuts[17]= fVertexerTracksTPCMVScanStep;
	296	if (n>18) cuts[18]= fVertexerTracksTPCMVMaxWghNtr;
	297	if (n>19) cuts[19]= fVertexerTracksTPCMVFinalWBinary;
	298	if (n>20) cuts[20]= fVertexerTracksTPCMVBCSpacing;
7878b3ae	299	//
	300	if (n>21) cuts[21]= fVertexerTracksTPCclusterize;
	301	if (n>22) cuts[22]= fVertexerTracksTPCclusterdz;
	302	if (n>23) cuts[23]= fVertexerTracksTPCclusternsigmaz;
a00021a7	303	} else {
8eaa1a42	304	if (n>0 ) cuts[0] = fVertexerTracksITSdcacut;
	305	if (n>1 ) cuts[1] = fVertexerTracksITSdcacutIter0;
	306	if (n>2 ) cuts[2] = fVertexerTracksITSmaxd0z0;
	307	if (n>3 ) cuts[3] = fVertexerTracksITSminCls;
	308	if (n>4 ) cuts[4] = fVertexerTracksITSmintrks;
	309	if (n>5 ) cuts[5] = fVertexerTracksITSnsigma;
	310	if (n>6 ) cuts[6] = fVertexerTracksITSnindetfitter;
	311	if (n>7 ) cuts[7] = fVertexerTracksITSmaxtgl;
	312	if (n>8 ) cuts[8] = fVertexerTracksITSfidR;
	313	if (n>9 ) cuts[9] = fVertexerTracksITSfidZ;
	314	if (n>10) cuts[10]= fVertexerTracksITSalgo;
	315	if (n>11) cuts[11]= fVertexerTracksITSalgoIter0;
3f2db92f	316	//
8eaa1a42	317	if (n>12) cuts[12]= fVertexerTracksITSMVTukey2;
	318	if (n>13) cuts[13]= fVertexerTracksITSMVSig2Ini;
	319	if (n>14) cuts[14]= fVertexerTracksITSMVMaxSigma2;
	320	if (n>15) cuts[15]= fVertexerTracksITSMVMinSig2Red;
	321	if (n>16) cuts[16]= fVertexerTracksITSMVMinDst;
	322	if (n>17) cuts[17]= fVertexerTracksITSMVScanStep;
	323	if (n>18) cuts[18]= fVertexerTracksITSMVMaxWghNtr;
	324	if (n>19) cuts[19]= fVertexerTracksITSMVFinalWBinary;
	325	if (n>20) cuts[20]= fVertexerTracksITSMVBCSpacing;
7878b3ae	326	//
	327	if (n>21) cuts[21]= fVertexerTracksITSclusterize;
	328	if (n>22) cuts[22]= fVertexerTracksITSclusterdz;
	329	if (n>23) cuts[23]= fVertexerTracksITSclusternsigmaz;
a00021a7	330	}
	331
	332	return;
	333	}
	334	//_____________________________________________________________________________
7878b3ae	335	void AliGRPRecoParam::SetVertexerTracksCuts(Int_t mode,Int_t ncuts,Double_t* cuts) {
a00021a7	336	//
	337	// set cuts for ITS (0) or TPC (1) mode
	338	//
	339	if(ncuts!=fVertexerTracksNCuts) {
	340	printf("AliGRPRecoParam: Number of AliVertexerTracks cuts is %d\n",fVertexerTracksNCuts);
	341	return;
	342	}
	343
	344	if(mode==1) {
8eaa1a42	345	if (ncuts>0) fVertexerTracksTPCdcacut = cuts[0];
	346	if (ncuts>1) fVertexerTracksTPCdcacutIter0 = cuts[1];
	347	if (ncuts>2) fVertexerTracksTPCmaxd0z0 = cuts[2];
	348	if (ncuts>3) fVertexerTracksTPCminCls = cuts[3];
	349	if (ncuts>4) fVertexerTracksTPCmintrks = cuts[4];
	350	if (ncuts>5) fVertexerTracksTPCnsigma = cuts[5];
	351	if (ncuts>6) fVertexerTracksTPCnindetfitter = cuts[6];
	352	if (ncuts>7) fVertexerTracksTPCmaxtgl = cuts[7];
	353	if (ncuts>8) fVertexerTracksTPCfidR = cuts[8];
	354	if (ncuts>9) fVertexerTracksTPCfidZ = cuts[9];
	355	if (ncuts>10) fVertexerTracksTPCalgo = cuts[10];
	356	if (ncuts>11) fVertexerTracksTPCalgoIter0 = cuts[11];
3f2db92f	357	//
8eaa1a42	358	if (ncuts>12) fVertexerTracksTPCMVTukey2 = cuts[12];
	359	if (ncuts>13) fVertexerTracksTPCMVSig2Ini = cuts[13];
	360	if (ncuts>14) fVertexerTracksTPCMVMaxSigma2 = cuts[14];
	361	if (ncuts>15) fVertexerTracksTPCMVMinSig2Red = cuts[15];
	362	if (ncuts>16) fVertexerTracksTPCMVMinDst = cuts[16];
	363	if (ncuts>17) fVertexerTracksTPCMVScanStep = cuts[17];
	364	if (ncuts>18) fVertexerTracksTPCMVMaxWghNtr = cuts[18];
	365	if (ncuts>19) fVertexerTracksTPCMVFinalWBinary = cuts[19];
	366	if (ncuts>20) fVertexerTracksTPCMVBCSpacing = cuts[20];
7878b3ae	367	//
	368	if (ncuts>21) fVertexerTracksTPCclusterize = cuts[21];
	369	if (ncuts>22) fVertexerTracksTPCclusterdz = cuts[22];
	370	if (ncuts>23) fVertexerTracksTPCclusternsigmaz = cuts[23];
a00021a7	371	} else {
8eaa1a42	372	if (ncuts>0) fVertexerTracksITSdcacut = cuts[0];
	373	if (ncuts>1) fVertexerTracksITSdcacutIter0 = cuts[1];
	374	if (ncuts>2) fVertexerTracksITSmaxd0z0 = cuts[2];
	375	if (ncuts>3) fVertexerTracksITSminCls = cuts[3];
	376	if (ncuts>4) fVertexerTracksITSmintrks = cuts[4];
	377	if (ncuts>5) fVertexerTracksITSnsigma = cuts[5];
	378	if (ncuts>6) fVertexerTracksITSnindetfitter = cuts[6];
	379	if (ncuts>7) fVertexerTracksITSmaxtgl = cuts[7];
	380	if (ncuts>8) fVertexerTracksITSfidR = cuts[8];
	381	if (ncuts>9) fVertexerTracksITSfidZ = cuts[9];
	382	if (ncuts>10) fVertexerTracksITSalgo = cuts[10];
	383	if (ncuts>11) fVertexerTracksITSalgoIter0 = cuts[11];
3f2db92f	384	//
8eaa1a42	385	if (ncuts>12) fVertexerTracksITSMVTukey2 = cuts[12];
	386	if (ncuts>13) fVertexerTracksITSMVSig2Ini = cuts[13];
	387	if (ncuts>14) fVertexerTracksITSMVMaxSigma2 = cuts[14];
	388	if (ncuts>15) fVertexerTracksITSMVMinSig2Red = cuts[15];
	389	if (ncuts>16) fVertexerTracksITSMVMinDst = cuts[16];
	390	if (ncuts>17) fVertexerTracksITSMVScanStep = cuts[17];
	391	if (ncuts>18) fVertexerTracksITSMVMaxWghNtr = cuts[18];
	392	if (ncuts>19) fVertexerTracksITSMVFinalWBinary = cuts[19];
	393	if (ncuts>20) fVertexerTracksITSMVBCSpacing = cuts[20];
7878b3ae	394	//
	395	if (ncuts>21) fVertexerTracksITSclusterize = cuts[21];
	396	if (ncuts>22) fVertexerTracksITSclusterdz = cuts[22];
	397	if (ncuts>23) fVertexerTracksITSclusternsigmaz = cuts[23];
a00021a7	398	}
8eaa1a42	399	//
a00021a7	400	return;
a00021a7	401	}
61a14552	402	//_____________________________________________________________________________
	403	void AliGRPRecoParam::GetVertexerV0Cuts(Double_t *cuts) const {
	404	//
	405	// get cuts for AliV0vertexer
	406	//
	407	cuts[0] = fVertexerV0Chi2max;
	408	cuts[1] = fVertexerV0DNmin;
	409	cuts[2] = fVertexerV0DPmin;
	410	cuts[3] = fVertexerV0DCAmax;
	411	cuts[4] = fVertexerV0CPAmin;
	412	cuts[5] = fVertexerV0Rmin;
	413	cuts[6] = fVertexerV0Rmax;
	414	return;
	415	}
	416	//_____________________________________________________________________________
	417	void AliGRPRecoParam::SetVertexerV0Cuts(Int_t ncuts,Double_t cuts[7]) {
	418	//
	419	// set cuts for AliV0vertexer
	420	//
	421	if(ncuts!=fVertexerV0NCuts) {
	422	printf("AliGRPRecoParam: Number of AliV0vertexer cuts is %d\n",fVertexerV0NCuts);
	423	return;
	424	}
	425	fVertexerV0Chi2max = cuts[0];
	426	fVertexerV0DNmin = cuts[1];
	427	fVertexerV0DPmin = cuts[2];
	428	fVertexerV0DCAmax = cuts[3];
	429	fVertexerV0CPAmin = cuts[4];
	430	fVertexerV0Rmin = cuts[5];
	431	fVertexerV0Rmax = cuts[6];
	432	return;
	433	}
	434	//_____________________________________________________________________________
	435	void AliGRPRecoParam::GetVertexerCascadeCuts(Double_t *cuts) const {
	436	//
	437	// get cuts for AliCascadevertexer
	438	//
	439	cuts[0] = fVertexerCascadeChi2max;
	440	cuts[1] = fVertexerCascadeDV0min;
	441	cuts[2] = fVertexerCascadeMassWin;
	442	cuts[3] = fVertexerCascadeDBachMin;
	443	cuts[4] = fVertexerCascadeDCAmax;
	444	cuts[5] = fVertexerCascadeCPAmin;
	445	cuts[6] = fVertexerCascadeRmin;
	446	cuts[7] = fVertexerCascadeRmax;
	447	return;
	448	}
	449	//_____________________________________________________________________________
	450	void AliGRPRecoParam::SetVertexerCascadeCuts(Int_t ncuts,Double_t cuts[8]) {
	451	//
	452	// set cuts for AliCascadeVertexer
	453	//
	454	if(ncuts!=fVertexerCascadeNCuts) {
	455	printf("AliGRPRecoParam: Number of AliCascadeVertexer cuts is %d\n",fVertexerCascadeNCuts);
	456	return;
	457	}
	458	fVertexerCascadeChi2max = cuts[0];
	459	fVertexerCascadeDV0min = cuts[1];
	460	fVertexerCascadeMassWin = cuts[2];
	461	fVertexerCascadeDBachMin = cuts[3];
	462	fVertexerCascadeDCAmax = cuts[4];
	463	fVertexerCascadeCPAmin = cuts[5];
	464	fVertexerCascadeRmin = cuts[6];
	465	fVertexerCascadeRmax = cuts[7];
466	return;
467	}