#ifndef ALIITSRECOPARAM_H
#define ALIITSRECOPARAM_H
#include "AliDetectorRecoParam.h"
#include "AliITSgeomTGeo.h"
class AliESDV0Params;
class AliITSRecoParam : public AliDetectorRecoParam
{
public:
AliITSRecoParam();
virtual ~AliITSRecoParam();
static AliITSRecoParam *GetLowFluxParam();
static AliITSRecoParam *GetHighFluxParam();
static AliITSRecoParam *GetCosmicTestParam();
static AliITSRecoParam *GetPlaneEffParam(Int_t i);
static Int_t GetLayersNotToSkip(Int_t i) { return fgkLayersNotToSkip[i]; }
static Int_t GetLastLayerToTrackTo() { return fgkLastLayerToTrackTo; }
static Int_t GetMaxClusterPerLayer() { return kMaxClusterPerLayer; }
static Int_t GetMaxClusterPerLayer5() { return kMaxClusterPerLayer5; }
static Int_t GetMaxClusterPerLayer10() { return kMaxClusterPerLayer10; }
static Int_t GetMaxClusterPerLayer20() { return kMaxClusterPerLayer20; }
static Int_t GetMaxDetectorPerLayer() { return fgkMaxDetectorPerLayer; }
static Double_t Getriw() { return fgkriw; }
static Double_t Getdiw() { return fgkdiw; }
static Double_t GetX0iw() { return fgkX0iw; }
static Double_t Getrcd() { return fgkrcd; }
static Double_t Getdcd() { return fgkdcd; }
static Double_t GetX0cd() { return fgkX0cd; }
static Double_t Getyr() { return fgkyr; }
static Double_t Getdr() { return fgkdr; }
static Double_t Getzm() { return fgkzm; }
static Double_t Getdm() { return fgkdm; }
static Double_t Getrs() { return fgkrs; }
static Double_t Getds() { return fgkds; }
static Double_t GetrInsideITSscreen() { return fgkrInsideITSscreen; }
static Double_t GetrInsideSPD1() { return fgkrInsideSPD1; }
static Double_t GetrPipe() { return fgkrPipe; }
static Double_t GetrInsidePipe() { return fgkrInsidePipe; }
static Double_t GetrOutsidePipe() { return fgkrOutsidePipe; }
static Double_t GetdPipe() { return fgkdPipe; }
static Double_t GetrInsideShield(Int_t i) { return fgkrInsideShield[i]; }
static Double_t GetrOutsideShield(Int_t i) { return fgkrOutsideShield[i]; }
static Double_t Getdshield(Int_t i) { return fgkdshield[i]; }
static Double_t GetX0shield(Int_t i) { return fgkX0shield[i]; }
static Double_t GetX0Air() { return fgkX0Air; }
static Double_t GetX0Be() { return fgkX0Be; }
static Double_t GetBoundaryWidth() { return fgkBoundaryWidth; }
static Double_t GetDeltaXNeighbDets() { return fgkDeltaXNeighbDets; }
static Double_t GetSPDdetzlength() { return fgkSPDdetzlength; }
static Double_t GetSPDdetxlength() { return fgkSPDdetxlength; }
void PrintParameters() const;
void SetTracker(Int_t tracker=0) { fTracker=tracker; }
void SetTrackerDefault() { SetTracker(0); }
void SetTrackerMI() { SetTracker(1); }
void SetTrackerV2() { SetTracker(2); }
Int_t GetTracker() const { return fTracker; }
void SetTrackerSAOnly(Bool_t flag=kTRUE) { fITSonly=flag; }
Bool_t GetTrackerSAOnly() const { return fITSonly; }
void SetVertexer(Int_t vertexer=0) { fVertexer=vertexer; }
void SetVertexer3D() { SetVertexer(0); }
void SetVertexerZ() { SetVertexer(1); }
void SetVertexerCosmics() { SetVertexer(2); }
void SetVertexerIons() { SetVertexer(3); }
void SetVertexerSmearMC(Float_t smearx=0.005, Float_t smeary=0.005, Float_t smearz=0.01) {
fVertexerFastSmearX=smearx; fVertexerFastSmearY=smeary; fVertexerFastSmearZ=smearz; SetVertexer(4);
}
void SetVertexerFixedOnTDI() {SetVertexer(5);}
void SetVertexerFixedOnTED() {SetVertexer(6);}
Int_t GetVertexer() const { return fVertexer; }
Float_t GetVertexerFastSmearX() const {return fVertexerFastSmearX;}
Float_t GetVertexerFastSmearY() const {return fVertexerFastSmearY;}
Float_t GetVertexerFastSmearZ() const {return fVertexerFastSmearZ;}
void SetPID(Int_t pid=0) {fPID=pid;}
void SetDefaultPID() {SetPID(0);}
void SetLandauFitPID() {SetPID(1);}
Int_t GetPID() const {return fPID;}
void SetVertexer3DFiducialRegions(Float_t dzwid=40.0, Float_t drwid=2.5, Float_t dznar=0.5, Float_t drnar=0.5){
SetVertexer3DWideFiducialRegion(dzwid,drwid);
SetVertexer3DNarrowFiducialRegion(dznar,drnar);
}
void SetVertexer3DWideFiducialRegion(Float_t dz=40.0, Float_t dr=2.5){
fVtxr3DZCutWide=dz; fVtxr3DRCutWide=dr;
}
void SetVertexer3DNarrowFiducialRegion(Float_t dz=0.5, Float_t dr=0.5){
fVtxr3DZCutNarrow=dz; fVtxr3DRCutNarrow=dr;
}
void SetVertexer3DDeltaPhiCuts(Float_t dphiloose=0.5, Float_t dphitight=0.025){
fVtxr3DPhiCutLoose=dphiloose;
fVtxr3DPhiCutTight=dphitight;
}
void SetVertexer3DDCACut(Float_t dca=0.1){
fVtxr3DDCACut=dca;
}
void SetVertexer3DDefaults(){
SetVertexer3DFiducialRegions();
SetVertexer3DDeltaPhiCuts();
SetVertexer3DDCACut();
}
void SetSPDVertexerPileupAlgoOff(){fVtxr3DPileupAlgo=3;}
void SetSPDVertexerPileupAlgoZ(){fVtxr3DPileupAlgo=0;}
void SetSPDVertexerPileupAlgo3DTwoSteps(){fVtxr3DPileupAlgo=1;}
void SetSPDVertexerPileupAlgo3DOneShot(){fVtxr3DPileupAlgo=2;}
void SetSPDVertexerHighMultAlgoDownscale(){fVtxr3DHighMultAlgo=0;}
void SetSPDVertexerHighMultAlgoTraces(){fVtxr3DHighMultAlgo=1;}
Bool_t GetSelectBestMIP03() const {return fSelectBestMIP03;}
Bool_t GetFlagFakes() const {return fFlagFakes;}
Bool_t GetUseImproveKalman() const {return fUseImproveKalman;}
void SetSelectBestMIP03(Bool_t v=kTRUE) {fSelectBestMIP03 = v;}
void SetFlagFakes(Bool_t v=kTRUE) {fFlagFakes = v;}
void SetUseImproveKalman(Bool_t v=kTRUE) {fUseImproveKalman = v;}
Float_t GetVertexer3DWideFiducialRegionZ() const {return fVtxr3DZCutWide;}
Float_t GetVertexer3DWideFiducialRegionR() const {return fVtxr3DRCutWide;}
Float_t GetVertexer3DNarrowFiducialRegionZ() const {return fVtxr3DZCutNarrow;}
Float_t GetVertexer3DNarrowFiducialRegionR() const {return fVtxr3DRCutNarrow;}
Float_t GetVertexer3DLooseDeltaPhiCut() const {return fVtxr3DPhiCutLoose;}
Float_t GetVertexer3DTightDeltaPhiCut() const {return fVtxr3DPhiCutTight;}
Float_t GetVertexer3DDCACut() const {return fVtxr3DDCACut;}
Int_t GetSPDVertexerPileupAlgo() const {return fVtxr3DPileupAlgo;}
UChar_t GetSPDVertexerHighMultAlgo() const {return fVtxr3DHighMultAlgo;}
Double_t GetSigmaY2(Int_t i) const { return fSigmaY2[i]; }
Double_t GetSigmaZ2(Int_t i) const { return fSigmaZ2[i]; }
Double_t GetMaxSnp() const { return fMaxSnp; }
Double_t GetNSigmaYLayerForRoadY() const { return fNSigmaYLayerForRoadY; }
Double_t GetNSigmaRoadY() const { return fNSigmaRoadY; }
Double_t GetNSigmaZLayerForRoadZ() const { return fNSigmaZLayerForRoadZ; }
Double_t GetNSigmaRoadZ() const { return fNSigmaRoadZ; }
Double_t GetNSigma2RoadYC() const { return fNSigma2RoadYC; }
Double_t GetNSigma2RoadZC() const { return fNSigma2RoadZC; }
Double_t GetNSigma2RoadYNonC() const { return fNSigma2RoadYNonC; }
Double_t GetNSigma2RoadZNonC() const { return fNSigma2RoadZNonC; }
Double_t GetRoadMisal() const { return fRoadMisal; }
void SetRoadMisal(Double_t road=0) { fRoadMisal=road; }
Double_t GetChi2PerCluster() const { return fChi2PerCluster; }
Double_t GetMaxChi2PerCluster(Int_t i) const { return fMaxChi2PerCluster[i]; }
Double_t GetMaxNormChi2NonC(Int_t i) const { return fMaxNormChi2NonC[i]; }
Double_t GetMaxNormChi2C(Int_t i) const { return fMaxNormChi2C[i]; }
Double_t GetMaxNormChi2NonCForHypothesis() const { return fMaxNormChi2NonCForHypothesis; }
Double_t GetMaxChi2() const { return fMaxChi2; }
Double_t GetMaxChi2s(Int_t i) const { return fMaxChi2s[i]; }
Double_t GetMaxChi2sR(Int_t i) const { return fMaxChi2sR[i]; }
Double_t GetMaxChi2In() const { return fMaxChi2In; }
Double_t GetMaxRoad() const { return fMaxRoad; }
Double_t GetMaxNormChi2ForGolden(Int_t i) const { return 3.+0.5*i; }
void SetSearchForExtraClusters(Bool_t opt=kTRUE){ fSearchForExtras=opt; }
Double_t GetSearchForExtraClusters() const { return fSearchForExtras; }
Double_t GetXVdef() const { return fXV; }
Double_t GetYVdef() const { return fYV; }
Double_t GetZVdef() const { return fZV; }
Double_t GetSigmaXVdef() const { return fSigmaXV; }
Double_t GetSigmaYVdef() const { return fSigmaYV; }
Double_t GetSigmaZVdef() const { return fSigmaZV; }
Double_t GetVertexCut() const { return fVertexCut; }
Double_t GetMaxDZforPrimTrk() const { return fMaxDZforPrimTrk; }
Double_t GetMaxDZToUseConstraint() const { return fMaxDZToUseConstraint; }
Double_t GetMaxDforV0dghtrForProlongation() const { return fMaxDforV0dghtrForProlongation; }
Double_t GetMaxDForProlongation() const { return fMaxDForProlongation; }
Double_t GetMaxDZForProlongation() const { return fMaxDZForProlongation; }
Double_t GetMinPtForProlongation() const { return fMinPtForProlongation; }
void SetAddVirtualClustersInDeadZone(Bool_t add=kTRUE) { fAddVirtualClustersInDeadZone=add; return; }
Bool_t GetAddVirtualClustersInDeadZone() const { return fAddVirtualClustersInDeadZone; }
Double_t GetZWindowDeadZone() const { return fZWindowDeadZone; }
Double_t GetSigmaXDeadZoneHit2() const { return fSigmaXDeadZoneHit2; }
Double_t GetSigmaZDeadZoneHit2() const { return fSigmaZDeadZoneHit2; }
Double_t GetXPassDeadZoneHits() const { return fXPassDeadZoneHits; }
Bool_t GetSkipSubdetsNotInTriggerCluster() const { return fSkipSubdetsNotInTriggerCluster; }
void SetSkipSubdetsNotInTriggerCluster(Bool_t flag=kTRUE) { fSkipSubdetsNotInTriggerCluster=flag; }
void SetUseTGeoInTracker(Int_t use=1) { fUseTGeoInTracker=use; return; }
Int_t GetUseTGeoInTracker() const { return fUseTGeoInTracker; }
void SetStepSizeTGeo(Double_t size=0.1) { fStepSizeTGeo=size; return; }
Double_t GetStepSizeTGeo() const { return fStepSizeTGeo; }
void SetAllowSharedClusters(Bool_t allow=kTRUE) { fAllowSharedClusters=allow; return; }
Bool_t GetAllowSharedClusters() const { return fAllowSharedClusters; }
void SetClusterErrorsParam(Int_t param=1) { fClusterErrorsParam=param; return; }
Int_t GetClusterErrorsParam() const { return fClusterErrorsParam; }
void SetClusterMisalErrorY(Float_t e0,Float_t e1,Float_t e2,Float_t e3,Float_t e4,Float_t e5) { fClusterMisalErrorY[0]=e0; fClusterMisalErrorY[1]=e1; fClusterMisalErrorY[2]=e2; fClusterMisalErrorY[3]=e3; fClusterMisalErrorY[4]=e4; fClusterMisalErrorY[5]=e5; return; }
void SetClusterMisalErrorZ(Float_t e0,Float_t e1,Float_t e2,Float_t e3,Float_t e4,Float_t e5) { fClusterMisalErrorZ[0]=e0; fClusterMisalErrorZ[1]=e1; fClusterMisalErrorZ[2]=e2; fClusterMisalErrorZ[3]=e3; fClusterMisalErrorZ[4]=e4; fClusterMisalErrorZ[5]=e5; return; }
void SetClusterMisalError(Float_t err=0.) { SetClusterMisalErrorY(err,err,err,err,err,err); SetClusterMisalErrorZ(err,err,err,err,err,err); }
void SetClusterMisalErrorYBOn(Float_t e0,Float_t e1,Float_t e2,Float_t e3,Float_t e4,Float_t e5) { fClusterMisalErrorYBOn[0]=e0; fClusterMisalErrorYBOn[1]=e1; fClusterMisalErrorYBOn[2]=e2; fClusterMisalErrorYBOn[3]=e3; fClusterMisalErrorYBOn[4]=e4; fClusterMisalErrorYBOn[5]=e5; return; }
void SetClusterMisalErrorZBOn(Float_t e0,Float_t e1,Float_t e2,Float_t e3,Float_t e4,Float_t e5) { fClusterMisalErrorZBOn[0]=e0; fClusterMisalErrorZBOn[1]=e1; fClusterMisalErrorZBOn[2]=e2; fClusterMisalErrorZBOn[3]=e3; fClusterMisalErrorZBOn[4]=e4; fClusterMisalErrorZBOn[5]=e5; return; }
void SetClusterMisalErrorBOn(Float_t err=0.) { SetClusterMisalErrorYBOn(err,err,err,err,err,err); SetClusterMisalErrorZBOn(err,err,err,err,err,err); }
Float_t GetClusterMisalErrorY(Int_t i,Double_t b=0.) const { return (TMath::Abs(b)<0.0001 ? fClusterMisalErrorY[i] : fClusterMisalErrorYBOn[i]); }
Float_t GetClusterMisalErrorZ(Int_t i,Double_t b=0.) const { return (TMath::Abs(b)<0.0001 ? fClusterMisalErrorZ[i] : fClusterMisalErrorZBOn[i]); }
void SetUseAmplitudeInfo(Bool_t use=kTRUE) { for(Int_t i=0;i<AliITSgeomTGeo::kNLayers;i++) fUseAmplitudeInfo[i]=use; return; }
void SetUseAmplitudeInfo(Int_t ilay,Bool_t use) { fUseAmplitudeInfo[ilay]=use; return; }
Bool_t GetUseAmplitudeInfo(Int_t ilay) const { return fUseAmplitudeInfo[ilay]; }
void SetComputePlaneEff(Bool_t eff=kTRUE, Bool_t his=kTRUE)
{ fComputePlaneEff=eff; fHistoPlaneEff=his; return; }
Bool_t GetComputePlaneEff() const { return fComputePlaneEff; }
Bool_t GetHistoPlaneEff() const { return fHistoPlaneEff; }
void SetUseTrackletsPlaneEff(Bool_t use=kTRUE) {fUseTrackletsPlaneEff=use; return;}
Bool_t GetUseTrackletsPlaneEff() const {return fUseTrackletsPlaneEff;}
void SetOptTrackletsPlaneEff(Bool_t mc=kFALSE,Bool_t bkg=kFALSE)
{fMCTrackletsPlaneEff=mc;fBkgTrackletsPlaneEff=bkg; return;}
Bool_t GetMCTrackletsPlaneEff() const {return fMCTrackletsPlaneEff;}
Bool_t GetBkgTrackletsPlaneEff() const {return fBkgTrackletsPlaneEff;}
void SetTrackleterPhiWindowL1(Float_t w=0.10) {fTrackleterPhiWindowL1=w; return;}
Float_t GetTrackleterPhiWindowL1() const {return fTrackleterPhiWindowL1;}
void SetTrackleterPhiWindowL2(Float_t w=0.07) {fTrackleterPhiWindowL2=w; return;}
Float_t GetTrackleterPhiWindowL2() const {return fTrackleterPhiWindowL2;}
void SetTrackleterZetaWindowL1(Float_t w=0.6) {fTrackleterZetaWindowL1=w; return;}
Float_t GetTrackleterZetaWindowL1() const {return fTrackleterZetaWindowL1;}
void SetTrackleterZetaWindowL2(Float_t w=0.40) {fTrackleterZetaWindowL2=w; return;}
Float_t GetTrackleterZetaWindowL2() const {return fTrackleterZetaWindowL2;}
void SetTrackleterBuildCl2TrkRefs(Bool_t v=kTRUE) {fTrackleterBuildCl2TrkRefs = v;}
Bool_t GetTrackleterBuildCl2TrkRefs() const { return fTrackleterBuildCl2TrkRefs;}
void SetUpdateOncePerEventPlaneEff(Bool_t use=kTRUE) {fUpdateOncePerEventPlaneEff=use; return;}
Bool_t GetUpdateOncePerEventPlaneEff() const {return fUpdateOncePerEventPlaneEff;}
void SetMinContVtxPlaneEff(Int_t n=3) {fMinContVtxPlaneEff=n; return;}
Int_t GetMinContVtxPlaneEff() const {return fMinContVtxPlaneEff;}
void SetIPlanePlaneEff(Int_t i=0) {if(i<-1 || i>=AliITSgeomTGeo::kNLayers) return; fIPlanePlaneEff=i; }
Int_t GetIPlanePlaneEff() const {return fIPlanePlaneEff;}
void SetReadPlaneEffFrom0CDB(Bool_t read=kTRUE) { fReadPlaneEffFromOCDB=read; }
Bool_t GetReadPlaneEffFromOCDB() const { return fReadPlaneEffFromOCDB; }
void SetMinPtPlaneEff(Bool_t ptmin=0.) { fMinPtPlaneEff=ptmin; }
Double_t GetMinPtPlaneEff() const { return fMinPtPlaneEff; }
void SetMaxMissingClustersPlaneEff(Int_t max=0) { fMaxMissingClustersPlaneEff=max;}
Int_t GetMaxMissingClustersPlaneEff() const {return fMaxMissingClustersPlaneEff;}
void SetMaxMissingClustersOutPlaneEff(Int_t max=0) { fMaxMissingClustersOutPlaneEff=max;}
Int_t GetMaxMissingClustersOutPlaneEff() const {return fMaxMissingClustersOutPlaneEff;}
void SetRequireClusterInOuterLayerPlaneEff(Bool_t out=kTRUE) { fRequireClusterInOuterLayerPlaneEff=out;}
Bool_t GetRequireClusterInOuterLayerPlaneEff() const {return fRequireClusterInOuterLayerPlaneEff;}
void SetRequireClusterInInnerLayerPlaneEff(Bool_t in=kTRUE) { fRequireClusterInInnerLayerPlaneEff=in;}
Bool_t GetRequireClusterInInnerLayerPlaneEff() const {return fRequireClusterInInnerLayerPlaneEff;}
void SetOnlyConstraintPlaneEff(Bool_t con=kFALSE) { fOnlyConstraintPlaneEff=con; }
Bool_t GetOnlyConstraintPlaneEff() const { return fOnlyConstraintPlaneEff; }
void SetNSigXFromBoundaryPlaneEff(Double_t nsigx=0.) {if(nsigx<0.)fNSigXFromBoundaryPlaneEff=TMath::Abs(nsigx);else fNSigXFromBoundaryPlaneEff=nsigx;}
Double_t GetNSigXFromBoundaryPlaneEff() const {return fNSigXFromBoundaryPlaneEff;}
void SetNSigZFromBoundaryPlaneEff(Double_t nsigz=0.) {if(nsigz<0.)fNSigZFromBoundaryPlaneEff=TMath::Abs(nsigz);else fNSigZFromBoundaryPlaneEff=nsigz;}
Double_t GetNSigZFromBoundaryPlaneEff() const {return fNSigZFromBoundaryPlaneEff;}
void SetDistXFromBoundaryPlaneEff(Double_t distx=0.) {if(distx<0.)fDistXFromBoundaryPlaneEff=TMath::Abs(distx);else fDistXFromBoundaryPlaneEff=distx;}
Double_t GetDistXFromBoundaryPlaneEff() const {return fDistXFromBoundaryPlaneEff;}
void SetDistZFromBoundaryPlaneEff(Double_t distz=0.) {if(distz<0.)fDistZFromBoundaryPlaneEff=TMath::Abs(distz);else fDistZFromBoundaryPlaneEff=distz;}
Double_t GetDistZFromBoundaryPlaneEff() const {return fDistZFromBoundaryPlaneEff;}
void SetSwitchOnMaxDistNSigFrmBndPlaneEff(Bool_t flagbnd=kFALSE) {fSwitchOnMaxDistNSigFrmBndPlaneEff=flagbnd;}
Bool_t GetSwitchOnMaxDistNSigFrmBndPlaneEff() const {return fSwitchOnMaxDistNSigFrmBndPlaneEff;}
void SetSwitchOffStdSearchClusPlaneEff(Bool_t flagstdclus=kFALSE) {fSwitchOffStdSearchClusPlaneEff=flagstdclus;}
Bool_t GetSwitchOffStdSearchClusPlaneEff() const {return fSwitchOffStdSearchClusPlaneEff;}
void SetNSigXSearchClusterPlaneEff(Double_t nsigclx=0.) {if(nsigclx<0.)fNSigXSearchClusterPlaneEff=TMath::Abs(nsigclx);else fNSigXSearchClusterPlaneEff=nsigclx;}
Double_t GetNSigXSearchClusterPlaneEff() const {return fNSigXSearchClusterPlaneEff;}
void SetNSigZSearchClusterPlaneEff(Double_t nsigclz=0.) {if(nsigclz<0.)fNSigZSearchClusterPlaneEff=TMath::Abs(nsigclz);else fNSigZSearchClusterPlaneEff=nsigclz;}
Double_t GetNSigZSearchClusterPlaneEff() const {return fNSigZSearchClusterPlaneEff;}
void SetDistXSearchClusterPlaneEff(Double_t distclx=0.) {if(distclx<0.)fDistXSearchClusterPlaneEff=TMath::Abs(distclx);else fDistXSearchClusterPlaneEff=distclx;}
Double_t GetDistXSearchClusterPlaneEff() const {return fDistXSearchClusterPlaneEff;}
void SetDistZSearchClusterPlaneEff(Double_t distclz=0.) {if(distclz<0.)fDistZSearchClusterPlaneEff=TMath::Abs(distclz);else fDistZSearchClusterPlaneEff=distclz;}
Double_t GetDistZSearchClusterPlaneEff() const {return fDistZSearchClusterPlaneEff;}
void SetSwitchOnMaxDistNSigSrhClusPlaneEff(Bool_t flagbndcl=kFALSE) {fSwitchOnMaxDistNSigSrhClusPlaneEff=flagbndcl;}
Bool_t GetSwitchOnMaxDistNSigSrhClusPlaneEff() const {return fSwitchOnMaxDistNSigSrhClusPlaneEff;}
void SetDCACutPlaneEff(Double_t dcacpe=999.) {fDCACutPlaneEff=dcacpe;}
Double_t GetDCACutPlaneEff() const {return fDCACutPlaneEff;}
void SetVertexChi2CutPlaneEff(Double_t vtxchipe=999999999.) {fVertexChi2CutPlaneEff=vtxchipe;}
Double_t GetVertexChi2CutPlaneEff() const {return fVertexChi2CutPlaneEff;}
void SetImproveWithVertex(Bool_t impr=kFALSE) { fImproveWithVertex=impr; return; }
Bool_t GetImproveWithVertex() const { return fImproveWithVertex; }
void SetExtendedEtaAcceptance(Bool_t ext=kTRUE) { fExtendedEtaAcceptance=ext; return; }
Bool_t GetExtendedEtaAcceptance() const { return fExtendedEtaAcceptance; }
void SetAllowProlongationWithEmptyRoad(Bool_t allow=kTRUE) { fAllowProlongationWithEmptyRoad=allow; return; }
Bool_t GetAllowProlongationWithEmptyRoad() const { return fAllowProlongationWithEmptyRoad; }
void SetUseBadZonesFromOCDB(Bool_t use=kTRUE) { fUseBadZonesFromOCDB=use; return; }
Bool_t GetUseBadZonesFromOCDB() const { return fUseBadZonesFromOCDB; }
void SetUseSingleBadChannelsFromOCDB(Bool_t use=kTRUE) { fUseSingleBadChannelsFromOCDB=use; return; }
Bool_t GetUseSingleBadChannelsFromOCDB() const { return fUseSingleBadChannelsFromOCDB; }
void SetMinFractionOfBadInRoad(Float_t frac=0) { fMinFractionOfBadInRoad=frac; return; }
Float_t GetMinFractionOfBadInRoad() const { return fMinFractionOfBadInRoad; }
void SetOutwardFindingSA() {fInwardFlagSA=kFALSE;}
void SetInwardFindingSA() {fInwardFlagSA=kTRUE;}
Bool_t GetInwardFindingSA() const {return fInwardFlagSA;}
void SetOuterStartLayerSA(Int_t lay) { fOuterStartLayerSA=lay; return; }
Int_t GetOuterStartLayerSA() const { return fOuterStartLayerSA; }
void SetInnerStartLayerSA(Int_t lay) { fInnerStartLayerSA=lay; return; }
Int_t GetInnerStartLayerSA() const { return fInnerStartLayerSA; }
void SetMinNPointsSA(Int_t np) { fMinNPointsSA=np; return; }
Int_t GetMinNPointsSA() const { return fMinNPointsSA;}
void SetFactorSAWindowSizes(Double_t fact=1.) { fFactorSAWindowSizes=fact; return; }
Double_t GetFactorSAWindowSizes() const { return fFactorSAWindowSizes; }
void SetNLoopsSA(Int_t nl=10) {fNLoopsSA=nl;}
Int_t GetNLoopsSA() const { return fNLoopsSA;}
void SetPhiLimitsSA(Double_t phimin,Double_t phimax){
fMinPhiSA=phimin; fMaxPhiSA=phimax;
}
Double_t GetMinPhiSA() const {return fMinPhiSA;}
Double_t GetMaxPhiSA() const {return fMaxPhiSA;}
void SetLambdaLimitsSA(Double_t lambmin,Double_t lambmax){
fMinLambdaSA=lambmin; fMaxLambdaSA=lambmax;
}
Double_t GetMinLambdaSA() const {return fMinLambdaSA;}
Double_t GetMaxLambdaSA() const {return fMaxLambdaSA;}
void SetSAMinClusterCharge(Float_t minq=0.) {fMinClusterChargeSA=minq;}
Float_t GetSAMinClusterCharge() const {return fMinClusterChargeSA;}
void SetSAOnePointTracks() { fSAOnePointTracks=kTRUE; return; }
Bool_t GetSAOnePointTracks() const { return fSAOnePointTracks; }
void SetSAUseAllClusters(Bool_t opt=kTRUE) { fSAUseAllClusters=opt; return; }
Bool_t GetSAUseAllClusters() const { return fSAUseAllClusters; }
void SetMaxSPDcontrForSAToUseAllClusters(Int_t contr=50) { fMaxSPDcontrForSAToUseAllClusters=contr; return; }
Int_t GetMaxSPDcontrForSAToUseAllClusters() const { return fMaxSPDcontrForSAToUseAllClusters; }
void SetSAUsedEdxInfo(Bool_t opt=kTRUE) { fSAUsedEdxInfo=opt; return; }
Bool_t GetSAUsedEdxInfo() const { return fSAUsedEdxInfo; }
void SetFindV0s(Bool_t find=kTRUE) { fFindV0s=find; return; }
Bool_t GetFindV0s() const { return fFindV0s; }
void SetStoreLikeSignV0s(Bool_t like=kFALSE) { fStoreLikeSignV0s=like; return; }
Bool_t GetStoreLikeSignV0s() const { return fStoreLikeSignV0s; }
void SetLayersParameters();
void SetLayerToSkip(Int_t i) { fLayersToSkip[i]=1; return; }
Int_t GetLayersToSkip(Int_t i) const { return fLayersToSkip[i]; }
void SetUseUnfoldingInClusterFinderSPD(Bool_t use=kTRUE) { fUseUnfoldingInClusterFinderSPD=use; return; }
Bool_t GetUseUnfoldingInClusterFinderSPD() const { return fUseUnfoldingInClusterFinderSPD; }
void SetUseUnfoldingInClusterFinderSDD(Bool_t use=kTRUE) { fUseUnfoldingInClusterFinderSDD=use; return; }
Bool_t GetUseUnfoldingInClusterFinderSDD() const { return fUseUnfoldingInClusterFinderSDD; }
void SetUseUnfoldingInClusterFinderSSD(Bool_t use=kTRUE) { fUseUnfoldingInClusterFinderSSD=use; return; }
Bool_t GetUseUnfoldingInClusterFinderSSD() const { return fUseUnfoldingInClusterFinderSSD; }
void SetUseBadChannelsInClusterFinderSSD(Bool_t use=kFALSE) { fUseBadChannelsInClusterFinderSSD=use; return; }
Bool_t GetUseBadChannelsInClusterFinderSSD() const { return fUseBadChannelsInClusterFinderSSD; }
void SetUseSDDCorrectionMaps(Bool_t use=kTRUE) {fUseSDDCorrectionMaps=use;}
Bool_t GetUseSDDCorrectionMaps() const {return fUseSDDCorrectionMaps;}
void SetUseSDDClusterSizeSelection(Bool_t use=kTRUE) {fUseSDDClusterSizeSelection=use;}
Bool_t GetUseSDDClusterSizeSelection() const {return fUseSDDClusterSizeSelection;}
void SetMinClusterChargeSDD(Float_t qcut=0.){fMinClusterChargeSDD=qcut;}
Float_t GetMinClusterChargeSDD() const {return fMinClusterChargeSDD;}
void SetUseChargeMatchingInClusterFinderSSD(Bool_t use=kTRUE) { fUseChargeMatchingInClusterFinderSSD=use; return; }
Bool_t GetUseChargeMatchingInClusterFinderSSD() const { return fUseChargeMatchingInClusterFinderSSD; }
void SetUseCosmicRunShiftsSSD(Bool_t use=kFALSE) { fUseCosmicRunShiftsSSD=use; return; }
Bool_t GetUseCosmicRunShiftsSSD() const { return fUseCosmicRunShiftsSSD; }
void SetTrackleterPhiWindow(Float_t w=0.08) {fTrackleterPhiWindow=w;}
void SetTrackleterThetaWindow(Float_t w=0.025) {fTrackleterThetaWindow=w;}
void SetTrackleterPhiShift(Float_t w=0.0045) {fTrackleterPhiShift=w;}
Float_t GetTrackleterPhiWindow() const {return fTrackleterPhiWindow;}
Float_t GetTrackleterThetaWindow() const {return fTrackleterThetaWindow;}
Float_t GetTrackleterPhiShift() const {return fTrackleterPhiShift;}
void SetTrackleterRemoveClustersFromOverlaps(Bool_t use=kTRUE) { fTrackleterRemoveClustersFromOverlaps=use; return; }
Bool_t GetTrackleterRemoveClustersFromOverlaps() const { return fTrackleterRemoveClustersFromOverlaps; }
void SetTrackleterPhiOverlapCut(Float_t w=0.005) {fTrackleterPhiOverlapCut=w;}
void SetTrackleterZetaOverlapCut(Float_t w=0.05) {fTrackleterZetaOverlapCut=w;}
Float_t GetTrackleterPhiOverlapCut() const {return fTrackleterPhiOverlapCut;}
Float_t GetTrackleterZetaOverlapCut() const {return fTrackleterZetaOverlapCut;}
void SetTrackleterPhiRotationAngle(Float_t w=0.0) {fTrackleterPhiRotationAngle=w;}
Float_t GetTrackleterPhiRotationAngle() const {return fTrackleterPhiRotationAngle;}
Bool_t GetTrackleterStoreSPD2SingleCl() const {return fTrackleterStoreSPD2SingleCl;}
void SetTrackleterStoreSPD2SingleCl(Bool_t v=kTRUE) {fTrackleterStoreSPD2SingleCl = v;}
void SetTrackleterNStdDevCut(Float_t f=1.) {fTrackleterNStdDev = f<0.01 ? 0.01 : f;}
Float_t GetTrackleterNStdDevCut() const {return fTrackleterNStdDev;}
void SetTrackleterScaleDThetaBySin2T(Bool_t v=kFALSE) {fScaleDTBySin2T = v;}
Bool_t GetTrackleterScaleDThetaBySin2T() const {return fScaleDTBySin2T;}
void SetSPDRemoveNoisyFlag(Bool_t value) {fSPDRemoveNoisyFlag = value;}
Bool_t GetSPDRemoveNoisyFlag() const {return fSPDRemoveNoisyFlag;}
void SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;}
Bool_t GetSPDRemoveDeadFlag() const {return fSPDRemoveDeadFlag;}
void SetAlignFilterCosmics(Bool_t b=kTRUE) {fAlignFilterCosmics=b;}
void SetAlignFilterCosmicMergeTracks(Bool_t b=kTRUE) {fAlignFilterCosmicMergeTracks=b;}
void SetAlignFilterMinITSPoints(Int_t n=4) {fAlignFilterMinITSPoints=n;}
void SetAlignFilterMinITSPointsMerged(Int_t n=4) {fAlignFilterMinITSPointsMerged=n;}
void SetAlignFilterOnlyITSSATracks(Bool_t b=kTRUE) {fAlignFilterOnlyITSSATracks=b;}
void SetAlignFilterOnlyITSTPCTracks(Bool_t b=kFALSE) {fAlignFilterOnlyITSTPCTracks=b;}
void SetAlignFilterUseLayer(Int_t ilay,Bool_t use) {fAlignFilterUseLayer[ilay]=use;}
void SetAlignFilterSkipExtra(Bool_t b=kFALSE) {fAlignFilterSkipExtra=b;}
void SetAlignFilterMaxMatchingAngle(Float_t max=0.085) {fAlignFilterMaxMatchingAngle=max;}
void SetAlignFilterMinAngleWrtModulePlanes(Float_t min=0.52) {fAlignFilterMinAngleWrtModulePlanes=min;}
void SetAlignFilterMinPt(Float_t min=0.) {fAlignFilterMinPt=min;}
void SetAlignFilterMaxPt(Float_t max=1.e10) {fAlignFilterMaxPt=max;}
void SetAlignFilterFillQANtuples(Bool_t b=kTRUE) {fAlignFilterFillQANtuples=b;}
Bool_t GetAlignFilterCosmics() const {return fAlignFilterCosmics;}
Bool_t GetAlignFilterCosmicMergeTracks() const {return fAlignFilterCosmicMergeTracks;}
Int_t GetAlignFilterMinITSPoints() const {return fAlignFilterMinITSPoints;}
Int_t GetAlignFilterMinITSPointsMerged() const {return fAlignFilterMinITSPointsMerged;}
Bool_t GetAlignFilterOnlyITSSATracks() const {return fAlignFilterOnlyITSSATracks;}
Bool_t GetAlignFilterOnlyITSTPCTracks() const {return fAlignFilterOnlyITSTPCTracks;}
Bool_t GetAlignFilterUseLayer(Int_t i) const {return fAlignFilterUseLayer[i];}
Bool_t GetAlignFilterSkipExtra() const {return fAlignFilterSkipExtra;}
Float_t GetAlignFilterMaxMatchingAngle() const {return fAlignFilterMaxMatchingAngle;}
Float_t GetAlignFilterMinAngleWrtModulePlanes() const {return fAlignFilterMinAngleWrtModulePlanes;}
Float_t GetAlignFilterMinPt() const {return fAlignFilterMinPt;}
Float_t GetAlignFilterMaxPt() const {return fAlignFilterMaxPt;}
Bool_t GetAlignFilterFillQANtuples() const {return fAlignFilterFillQANtuples;}
Float_t GetMultCutPxDrSPDin() const {return fMultCutPxDrSPDin;}
Float_t GetMultCutPxDrSPDout() const {return fMultCutPxDrSPDout;}
Float_t GetMultCutPxDz() const {return fMultCutPxDz;}
Float_t GetMultCutDCArz() const {return fMultCutDCArz;}
Float_t GetMultCutMinElectronProbTPC() const {return fMultCutMinElectronProbTPC;}
Float_t GetMultCutMinElectronProbESD() const {return fMultCutMinElectronProbESD;}
Float_t GetMultCutMinP() const {return fMultCutMinP;}
Float_t GetMultCutMinRGamma() const {return fMultCutMinRGamma;}
Float_t GetMultCutMinRK0() const {return fMultCutMinRK0;}
Float_t GetMultCutMinPointAngle() const {return fMultCutMinPointAngle;}
Float_t GetMultCutMaxDCADauther() const {return fMultCutMaxDCADauther;}
Float_t GetMultCutMassGamma() const {return fMultCutMassGamma;}
Float_t GetMultCutMassGammaNSigma() const {return fMultCutMassGammaNSigma;}
Float_t GetMultCutMassK0() const {return fMultCutMassK0;}
Float_t GetMultCutMassK0NSigma() const {return fMultCutMassK0NSigma;}
Float_t GetMultCutChi2cGamma() const {return fMultCutChi2cGamma;}
Float_t GetMultCutChi2cK0() const {return fMultCutChi2cK0;}
Float_t GetMultCutGammaSFromDecay() const {return fMultCutGammaSFromDecay;}
Float_t GetMultCutK0SFromDecay() const {return fMultCutK0SFromDecay;}
Float_t GetMultCutMaxDCA() const {return fMultCutMaxDCA;}
void SetMultCutPxDrSPDin(Float_t v=0.1) { fMultCutPxDrSPDin = v;}
void SetMultCutPxDrSPDout(Float_t v=0.15) { fMultCutPxDrSPDout = v;}
void SetMultCutPxDz(Float_t v=0.2) { fMultCutPxDz = v;}
void SetMultCutDCArz(Float_t v=0.5) { fMultCutDCArz = v;}
void SetMultCutMinElectronProbTPC(Float_t v=0.5) { fMultCutMinElectronProbTPC = v;}
void SetMultCutMinElectronProbESD(Float_t v=0.1) { fMultCutMinElectronProbESD = v;}
void SetMultCutMinP(Float_t v=0.05) { fMultCutMinP = v;}
void SetMultCutMinRGamma(Float_t v=2.) { fMultCutMinRGamma = v;}
void SetMultCutMinRK0(Float_t v=1.) { fMultCutMinRK0 = v;}
void SetMultCutMinPointAngle(Float_t v=0.98) { fMultCutMinPointAngle = v;}
void SetMultCutMaxDCADauther(Float_t v=0.5) { fMultCutMaxDCADauther = v;}
void SetMultCutMassGamma(Float_t v=0.03) { fMultCutMassGamma = v;}
void SetMultCutMassGammaNSigma(Float_t v=5.) { fMultCutMassGammaNSigma = v;}
void SetMultCutMassK0(Float_t v=0.03) { fMultCutMassK0 = v;}
void SetMultCutMassK0NSigma(Float_t v=5.) { fMultCutMassK0NSigma = v;}
void SetMultCutChi2cGamma(Float_t v=2.) { fMultCutChi2cGamma = v;}
void SetMultCutChi2cK0(Float_t v=2.) { fMultCutChi2cK0 = v;}
void SetMultCutGammaSFromDecay(Float_t v=-10.) { fMultCutGammaSFromDecay = v;}
void SetMultCutK0SFromDecay(Float_t v=-10.) { fMultCutK0SFromDecay = v;}
void SetMultCutMaxDCA(Float_t v=1.) { fMultCutMaxDCA = v;}
AliESDV0Params *GetESDV0Params() const {return fESDV0Params;}
Bool_t GetCorrectLorentzAngleSPD() const {return fCorrectLorentzAngleSPD;}
Float_t GetTanLorentzAngleHolesSPD() const {return fTanLorentzAngleHolesSPD;}
Bool_t GetCorrectLorentzAngleSSD() const {return fCorrectLorentzAngleSSD;}
Float_t GetTanLorentzAngleHolesSSD() const {return fTanLorentzAngleHolesSSD;}
Float_t GetTanLorentzAngleElectronsSSD() const {return fTanLorentzAngleElectronsSSD;}
void SetCorrectLorentzAngleSPD(Bool_t flag) {fCorrectLorentzAngleSPD=flag;}
void SetTanLorentzAngleHolesSPD(Float_t la) {fTanLorentzAngleHolesSPD=la;}
void SetCorrectLorentzAngleSSD(Bool_t flag) {fCorrectLorentzAngleSSD=flag;}
void SetTanLorentzAngleHolesSSD(Float_t la) {fTanLorentzAngleHolesSSD=la;}
void SetTanLorentzAngleElectronsSSD(Float_t la) {fTanLorentzAngleElectronsSSD=la;}
Bool_t SetOptReco(TString r);
void ReconstructOnlySPD(){fOptReco="SPD";}
TString GetOptReco() const {return fOptReco;}
enum {kMaxClusterPerLayer=70000};
enum {kMaxClusterPerLayer5=28000};
enum {kMaxClusterPerLayer10=14000};
enum {kMaxClusterPerLayer20=7000};
protected:
static const Int_t fgkLayersNotToSkip[AliITSgeomTGeo::kNLayers];
static const Int_t fgkLastLayerToTrackTo=0;
static const Int_t fgkMaxDetectorPerLayer=1000;
static const Double_t fgkriw;
static const Double_t fgkdiw;
static const Double_t fgkX0iw;
static const Double_t fgkrcd;
static const Double_t fgkdcd;
static const Double_t fgkX0cd;
static const Double_t fgkyr;
static const Double_t fgkdr;
static const Double_t fgkzm;
static const Double_t fgkdm;
static const Double_t fgkrs;
static const Double_t fgkds;
static const Double_t fgkrInsideITSscreen;
static const Double_t fgkrInsideSPD1;
static const Double_t fgkrPipe;
static const Double_t fgkrInsidePipe;
static const Double_t fgkrOutsidePipe;
static const Double_t fgkdPipe;
static const Double_t fgkrInsideShield[2];
static const Double_t fgkrOutsideShield[2];
static const Double_t fgkdshield[2];
static const Double_t fgkX0shield[2];
static const Double_t fgkX0Air;
static const Double_t fgkX0Be;
static const Double_t fgkBoundaryWidth;
static const Double_t fgkDeltaXNeighbDets;
static const Double_t fgkSPDdetzlength;
static const Double_t fgkSPDdetxlength;
Int_t fTracker;
Bool_t fITSonly;
Int_t fVertexer;
Int_t fPID;
Float_t fVtxr3DZCutWide;
Float_t fVtxr3DRCutWide;
Float_t fVtxr3DZCutNarrow;
Float_t fVtxr3DRCutNarrow;
Float_t fVtxr3DPhiCutLoose;
Float_t fVtxr3DPhiCutTight;
Float_t fVtxr3DDCACut;
Int_t fVtxr3DPileupAlgo;
UChar_t fVtxr3DHighMultAlgo;
Int_t fLayersToSkip[AliITSgeomTGeo::kNLayers];
Double_t fSigmaY2[AliITSgeomTGeo::kNLayers];
Double_t fSigmaZ2[AliITSgeomTGeo::kNLayers];
Double_t fMaxSnp;
Double_t fNSigmaYLayerForRoadY;
Double_t fNSigmaRoadY;
Double_t fNSigmaZLayerForRoadZ;
Double_t fNSigmaRoadZ;
Double_t fNSigma2RoadZC;
Double_t fNSigma2RoadYC;
Double_t fNSigma2RoadZNonC;
Double_t fNSigma2RoadYNonC;
Double_t fRoadMisal;
Double_t fMaxChi2PerCluster[AliITSgeomTGeo::kNLayers-1];
Double_t fMaxNormChi2NonC[AliITSgeomTGeo::kNLayers];
Double_t fMaxNormChi2C[AliITSgeomTGeo::kNLayers];
Double_t fMaxNormChi2NonCForHypothesis;
Double_t fMaxChi2;
Double_t fMaxChi2s[AliITSgeomTGeo::kNLayers];
Double_t fMaxRoad;
Double_t fMaxChi2In;
Double_t fMaxChi2sR[AliITSgeomTGeo::kNLayers];
Double_t fChi2PerCluster;
Bool_t fSearchForExtras;
Double_t fXV;
Double_t fYV;
Double_t fZV;
Double_t fSigmaXV;
Double_t fSigmaYV;
Double_t fSigmaZV;
Double_t fVertexCut;
Double_t fMaxDZforPrimTrk;
Double_t fMaxDZToUseConstraint;
Double_t fMaxDforV0dghtrForProlongation;
Double_t fMaxDForProlongation;
Double_t fMaxDZForProlongation;
Double_t fMinPtForProlongation;
Bool_t fAddVirtualClustersInDeadZone;
Double_t fZWindowDeadZone;
Double_t fSigmaXDeadZoneHit2;
Double_t fSigmaZDeadZoneHit2;
Double_t fXPassDeadZoneHits;
Bool_t fSkipSubdetsNotInTriggerCluster;
Int_t fUseTGeoInTracker;
Double_t fStepSizeTGeo;
Bool_t fAllowSharedClusters;
Int_t fClusterErrorsParam;
Float_t fClusterMisalErrorY[AliITSgeomTGeo::kNLayers];
Float_t fClusterMisalErrorZ[AliITSgeomTGeo::kNLayers];
Float_t fClusterMisalErrorYBOn[AliITSgeomTGeo::kNLayers];
Float_t fClusterMisalErrorZBOn[AliITSgeomTGeo::kNLayers];
Bool_t fUseAmplitudeInfo[AliITSgeomTGeo::kNLayers];
Bool_t fComputePlaneEff;
Bool_t fHistoPlaneEff;
Bool_t fUseTrackletsPlaneEff;
Bool_t fMCTrackletsPlaneEff;
Bool_t fBkgTrackletsPlaneEff;
Float_t fTrackleterPhiWindowL1;
Float_t fTrackleterPhiWindowL2;
Float_t fTrackleterZetaWindowL1;
Float_t fTrackleterZetaWindowL2;
Bool_t fUpdateOncePerEventPlaneEff;
Int_t fMinContVtxPlaneEff;
Int_t fIPlanePlaneEff;
Bool_t fReadPlaneEffFromOCDB;
Double_t fMinPtPlaneEff;
Int_t fMaxMissingClustersPlaneEff;
Int_t fMaxMissingClustersOutPlaneEff;
Bool_t fRequireClusterInOuterLayerPlaneEff;
Bool_t fRequireClusterInInnerLayerPlaneEff;
Bool_t fOnlyConstraintPlaneEff;
Double_t fNSigXFromBoundaryPlaneEff;
Double_t fNSigZFromBoundaryPlaneEff;
Double_t fDistXFromBoundaryPlaneEff;
Double_t fDistZFromBoundaryPlaneEff;
Bool_t fSwitchOnMaxDistNSigFrmBndPlaneEff;
Bool_t fSwitchOffStdSearchClusPlaneEff;
Double_t fNSigXSearchClusterPlaneEff;
Double_t fNSigZSearchClusterPlaneEff;
Double_t fDistXSearchClusterPlaneEff;
Double_t fDistZSearchClusterPlaneEff;
Bool_t fSwitchOnMaxDistNSigSrhClusPlaneEff;
Double_t fDCACutPlaneEff;
Double_t fVertexChi2CutPlaneEff;
Bool_t fImproveWithVertex;
Bool_t fExtendedEtaAcceptance;
Bool_t fUseBadZonesFromOCDB;
Bool_t fUseSingleBadChannelsFromOCDB;
Float_t fMinFractionOfBadInRoad;
Bool_t fAllowProlongationWithEmptyRoad;
Int_t fInwardFlagSA;
Int_t fOuterStartLayerSA;
Int_t fInnerStartLayerSA;
Int_t fMinNPointsSA;
Double_t fFactorSAWindowSizes;
Int_t fNLoopsSA;
Double_t fMinPhiSA;
Double_t fMaxPhiSA;
Double_t fMinLambdaSA;
Double_t fMaxLambdaSA;
Float_t fMinClusterChargeSA;
Bool_t fSAOnePointTracks;
Bool_t fSAUseAllClusters;
Int_t fMaxSPDcontrForSAToUseAllClusters;
Bool_t fSAUsedEdxInfo;
Bool_t fSelectBestMIP03;
Bool_t fFlagFakes;
Bool_t fUseImproveKalman;
Bool_t fFindV0s;
Bool_t fStoreLikeSignV0s;
Bool_t fUseUnfoldingInClusterFinderSPD;
Bool_t fUseUnfoldingInClusterFinderSDD;
Bool_t fUseUnfoldingInClusterFinderSSD;
Bool_t fUseBadChannelsInClusterFinderSSD;
Bool_t fUseSDDCorrectionMaps;
Bool_t fUseSDDClusterSizeSelection;
Float_t fMinClusterChargeSDD;
Bool_t fUseChargeMatchingInClusterFinderSSD;
Float_t fTrackleterPhiWindow;
Float_t fTrackleterThetaWindow;
Float_t fTrackleterPhiShift;
Bool_t fTrackleterRemoveClustersFromOverlaps;
Float_t fTrackleterPhiOverlapCut;
Float_t fTrackleterZetaOverlapCut;
Float_t fTrackleterPhiRotationAngle;
Float_t fTrackleterNStdDev;
Bool_t fScaleDTBySin2T;
Bool_t fTrackleterStoreSPD2SingleCl;
Bool_t fTrackleterBuildCl2TrkRefs;
Bool_t fUseCosmicRunShiftsSSD;
Bool_t fSPDRemoveNoisyFlag;
Bool_t fSPDRemoveDeadFlag;
Float_t fVertexerFastSmearX;
Float_t fVertexerFastSmearY;
Float_t fVertexerFastSmearZ;
Bool_t fAlignFilterCosmics;
Bool_t fAlignFilterCosmicMergeTracks;
Int_t fAlignFilterMinITSPoints;
Int_t fAlignFilterMinITSPointsMerged;
Bool_t fAlignFilterOnlyITSSATracks;
Bool_t fAlignFilterOnlyITSTPCTracks;
Bool_t fAlignFilterUseLayer[AliITSgeomTGeo::kNLayers];
Bool_t fAlignFilterSkipExtra;
Float_t fAlignFilterMaxMatchingAngle;
Float_t fAlignFilterMinAngleWrtModulePlanes;
Float_t fAlignFilterMinPt;
Float_t fAlignFilterMaxPt;
Bool_t fAlignFilterFillQANtuples;
Float_t fMultCutPxDrSPDin;
Float_t fMultCutPxDrSPDout;
Float_t fMultCutPxDz;
Float_t fMultCutDCArz;
Float_t fMultCutMinElectronProbTPC;
Float_t fMultCutMinElectronProbESD;
Float_t fMultCutMinP;
Float_t fMultCutMinRGamma;
Float_t fMultCutMinRK0;
Float_t fMultCutMinPointAngle;
Float_t fMultCutMaxDCADauther;
Float_t fMultCutMassGamma;
Float_t fMultCutMassGammaNSigma;
Float_t fMultCutMassK0;
Float_t fMultCutMassK0NSigma;
Float_t fMultCutChi2cGamma;
Float_t fMultCutChi2cK0;
Float_t fMultCutGammaSFromDecay;
Float_t fMultCutK0SFromDecay;
Float_t fMultCutMaxDCA;
Bool_t fCorrectLorentzAngleSPD;
Float_t fTanLorentzAngleHolesSPD;
Bool_t fCorrectLorentzAngleSSD;
Float_t fTanLorentzAngleHolesSSD;
Float_t fTanLorentzAngleElectronsSSD;
TString fOptReco;
private:
AliESDV0Params * fESDV0Params;
AliITSRecoParam(const AliITSRecoParam & param);
AliITSRecoParam & operator=(const AliITSRecoParam ¶m);
ClassDef(AliITSRecoParam,54)
};
#endif