class AliITSRecoParam: public AliDetectorRecoParam
Class with ITS reconstruction parameters Origin: andrea.dainese@lnl.infn.it
Function Members (Methods)
public:
protected:
| virtual void | TObject::DoError(int level, const char* location, const char* fmt, va_list va) const |
| void | TObject::MakeZombie() |
private:
| AliITSRecoParam(const AliITSRecoParam& param) | |
| AliITSRecoParam& | operator=(const AliITSRecoParam& param) |
Data Members
public:
| enum { | kMaxClusterPerLayer | |
| kMaxClusterPerLayer5 | ||
| kMaxClusterPerLayer10 | ||
| kMaxClusterPerLayer20 | ||
| }; | ||
| enum TObject::EStatusBits { | kCanDelete | |
| kMustCleanup | ||
| kObjInCanvas | ||
| kIsReferenced | ||
| kHasUUID | ||
| kCannotPick | ||
| kNoContextMenu | ||
| kInvalidObject | ||
| }; | ||
| enum TObject::[unnamed] { | kIsOnHeap | |
| kNotDeleted | ||
| kZombie | ||
| kBitMask | ||
| kSingleKey | ||
| kOverwrite | ||
| kWriteDelete | ||
| }; |
protected:
| Bool_t | fAddVirtualClustersInDeadZone | add if kTRUE |
| Bool_t | fAlignFilterCosmicMergeTracks | merge cosmic tracks |
| Bool_t | fAlignFilterCosmics | flag for cosmics case |
| Bool_t | fAlignFilterFillQANtuples | fill QA ntuples |
| Float_t | fAlignFilterMaxMatchingAngle | matching for cosmics |
| Float_t | fAlignFilterMaxPt | max pt |
| Float_t | fAlignFilterMinAngleWrtModulePlanes | min angle track-to-sensor |
| Int_t | fAlignFilterMinITSPoints | min points per track |
| Int_t | fAlignFilterMinITSPointsMerged | min points for merged tracks |
| Float_t | fAlignFilterMinPt | min pt |
| Bool_t | fAlignFilterOnlyITSSATracks | only ITS SA tracks |
| Bool_t | fAlignFilterOnlyITSTPCTracks | only ITS+TPC tracks |
| Bool_t | fAlignFilterSkipExtra | no extra cls in array |
| Bool_t | fAlignFilterUseLayer[6] | layers to use |
| Bool_t | fAllowProlongationWithEmptyRoad | allow to prolong even if road is empty (MI) |
| Bool_t | fAllowSharedClusters | if kFALSE don't set to kITSin tracks with shared clusters (MI) |
| Bool_t | fBkgTrackletsPlaneEff | flag to evaluate background instead of normal use (SPD PlaneEff using tracklets) |
| Double_t | fChi2PerCluster | (NOT USED) |
| Int_t | fClusterErrorsParam | parametrization for cluster errors (MI), see AliITSRecoParam::GetError() |
| Float_t | fClusterMisalErrorY[6] | [cm] additional error on cluster Y pos. due to misalignment (MI,SA) |
| Float_t | fClusterMisalErrorYBOn[6] | [cm] additional error on cluster Y pos. due to misalignment (MI,SA) |
| Float_t | fClusterMisalErrorZ[6] | [cm] additional error on cluster Z pos. due to misalignment (MI,SA) |
| Float_t | fClusterMisalErrorZBOn[6] | [cm] additional error on cluster Z pos. due to misalignment (MI,SA) |
| Bool_t | fComputePlaneEff | flag to enable computation of PlaneEfficiency |
| Bool_t | fCorrectLorentzAngleSPD | flag to enable correction |
| Bool_t | fCorrectLorentzAngleSSD | flag to enable correction |
| Double_t | fDCACutPlaneEff | this set the cut on DCA in rphi plane when evaluating PlaneEff(SPD0) |
| Double_t | fDistXFromBoundaryPlaneEff | accept one track for PlaneEff if distance from border (in loc x or z) |
| Double_t | fDistXSearchClusterPlaneEff | cluster found in distance from track impact point (in loc x or z) |
| Double_t | fDistZFromBoundaryPlaneEff | is greater than fDistXFromBoundaryPlaneEff centimeters |
| Double_t | fDistZSearchClusterPlaneEff | is greater than fDistXSearchClusterPlaneEff centimeters |
| Bool_t | fExtendedEtaAcceptance | enable jumping from TPC to SPD at large eta (MI) |
| Double_t | fFactorSAWindowSizes | larger window sizes in SA |
| Bool_t | fFindV0s | flag to enable V0 finder (MI) |
| Bool_t | fFlagFakes | (MI) preform shared cluster analysis and flag candidates for fakes |
| Bool_t | fHistoPlaneEff | flag to enable auxiliary PlaneEff histograms (e.g. residual distributions) |
| Int_t | fIPlanePlaneEff | index of the plane (in the range [-1,5]) to study the efficiency (-1 ->Tracklets) |
| Bool_t | fITSonly | tracking only in ITS (no TPC) |
| Bool_t | fImproveWithVertex | use the method AliITStrackV2::Improve() to point to the vertex during prolongation |
| Int_t | fInnerStartLayerSA | inner ITS layer to start track in SA inward |
| Int_t | fInwardFlagSA | flag for inward track finding in SA |
| Int_t | fLayersToSkip[6] | array with layers to skip (MI,SA) |
| Bool_t | fMCTrackletsPlaneEff | flag to enable the use of MC info for corrections (SPD PlaneEff using tracklets) |
| Double_t | fMaxChi2 | used to initialize variables needed to find minimum chi2 (MI,V2) |
| Double_t | fMaxChi2In | (NOT USED) |
| Double_t | fMaxChi2PerCluster[5] | max chi2 for MIP (MI) |
| Double_t | fMaxChi2s[6] | max predicted chi2 (cluster & track prol.) (MI) |
| Double_t | fMaxChi2sR[6] | (NOT USED) |
| Double_t | fMaxDForProlongation | max. rphi imp. par. cut |
| Double_t | fMaxDZForProlongation | max. 3D imp. par. cut |
| Double_t | fMaxDZToUseConstraint | maximum (imp. par.) for tracks to be |
| Double_t | fMaxDZforPrimTrk | maximum (imp. par.)/(1+layer) to define |
| Double_t | fMaxDforV0dghtrForProlongation | max. rphi imp. par. cut for V0 daughter |
| Double_t | fMaxLambdaSA | maximum lambda value for SA windows |
| Int_t | fMaxMissingClustersOutPlaneEff | max n. of outermost layers without a cluster associated to the track |
| Int_t | fMaxMissingClustersPlaneEff | max n. of (other) layers without a cluster associated to the track |
| Double_t | fMaxNormChi2C[6] | max norm chi2 for constrained tracks (MI) |
| Double_t | fMaxNormChi2NonC[6] | max norm chi2 for non constrained tracks (MI) |
| Double_t | fMaxNormChi2NonCForHypothesis | max norm chi2 (on layers 0,1,2) for hypotheis to be kept (MI) |
| Double_t | fMaxPhiSA | maximum phi value for SA windows |
| Double_t | fMaxRoad | (V2) |
| Int_t | fMaxSPDcontrForSAToUseAllClusters | maximum nContr of SPD vertex for which trackerSA will reuse all ITS clusters |
| Double_t | fMaxSnp | maximum of sin(phi) (MI) |
| Float_t | fMinClusterChargeSA | minimum SDD,SSD cluster charge for SA tarcker |
| Float_t | fMinClusterChargeSDD | cut on SDD cluster charge |
| Int_t | fMinContVtxPlaneEff | min number of contributors to ESD vtx for SPD PlaneEff using tracklets |
| Float_t | fMinFractionOfBadInRoad | to decide whether to skip the layer (MI) |
| Double_t | fMinLambdaSA | minimum lambda value for SA windows |
| Int_t | fMinNPointsSA | min. number of ITS clusters for a SA track |
| Double_t | fMinPhiSA | minimum phi value for SA windows |
| Double_t | fMinPtForProlongation | min. pt cut |
| Double_t | fMinPtPlaneEff | minimum p_t of the track to be used for Plane Efficiency evaluation |
| Float_t | fMultCutChi2cGamma | max constrained chi2 cut for gammas |
| Float_t | fMultCutChi2cK0 | max constrained chi2 cut for K0s |
| Float_t | fMultCutDCArz | max DR or DZ for primares |
| Float_t | fMultCutGammaSFromDecay | min path*P for gammas |
| Float_t | fMultCutK0SFromDecay | min path*P for K0s |
| Float_t | fMultCutMassGamma | max gamma mass |
| Float_t | fMultCutMassGammaNSigma | max standard deviations from 0 for gamma |
| Float_t | fMultCutMassK0 | max K0 mass difference from PGD value |
| Float_t | fMultCutMassK0NSigma | max standard deviations for K0 mass from PDG value |
| Float_t | fMultCutMaxDCA | max DCA for V0 at ESD vertex |
| Float_t | fMultCutMaxDCADauther | max DCA of daughters at V0 |
| Float_t | fMultCutMinElectronProbESD | min probability for e+/e- PID not involving TPC |
| Float_t | fMultCutMinElectronProbTPC | min probability for e+/e- PID involving TPC |
| Float_t | fMultCutMinP | min P of V0 |
| Float_t | fMultCutMinPointAngle | min pointing angle cosine |
| Float_t | fMultCutMinRGamma | min transv. distance from ESDVertex to V0 for gammas |
| Float_t | fMultCutMinRK0 | min transv. distance from ESDVertex to V0 for K0s |
| Float_t | fMultCutPxDrSPDin | max P*DR for primaries involving at least 1 SPD |
| Float_t | fMultCutPxDrSPDout | max P*DR for primaries not involving any SPD |
| Float_t | fMultCutPxDz | max P*DZ for primaries |
| Int_t | fNLoopsSA | number of loops in tracker SA |
| Double_t | fNSigXFromBoundaryPlaneEff | accept one track for PlaneEff if distance from border (in loc x or z) |
| Double_t | fNSigXSearchClusterPlaneEff | cluster search in distance from track impact point (in loc x or z) |
| Double_t | fNSigZFromBoundaryPlaneEff | is greater than fNSigXFromBoundaryPlaneEff * Track_precision |
| Double_t | fNSigZSearchClusterPlaneEff | less than fNSigXSearchClusterPlaneEff * Track_precision |
| Double_t | fNSigma2RoadYC | y |
| Double_t | fNSigma2RoadYNonC | y |
| Double_t | fNSigma2RoadZC | z |
| Double_t | fNSigma2RoadZNonC | z |
| Double_t | fNSigmaRoadY | y |
| Double_t | fNSigmaRoadZ | z |
| Double_t | fNSigmaYLayerForRoadY | y |
| Double_t | fNSigmaZLayerForRoadZ | z |
| TString | TNamed::fName | object identifier |
| Bool_t | fOnlyConstraintPlaneEff | if kTRUE, use only constrained tracks at primary vertex for Plane Eff. |
| TString | fOptReco | "All" by default. It can be any |
| Int_t | fOuterStartLayerSA | outer ITS layer to start track in SA outward |
| Int_t | fPID | ITS PID method to be used (see AliITSReconstructor) |
| Bool_t | fReadPlaneEffFromOCDB | enable initial reading of Plane Eff statistics from OCDB |
| Bool_t | fRequireClusterInInnerLayerPlaneEff | outer/inner layer are used. It has no effect for outermost/innermost layer |
| Bool_t | fRequireClusterInOuterLayerPlaneEff | if kTRUE, then only tracks with an associated cluster on the closest |
| Double_t | fRoadMisal | [cm] increase of road for misalignment (MI) |
| Bool_t | fSAOnePointTracks | one-cluster tracks in SA (only for cosmics!) |
| Bool_t | fSAUseAllClusters | do not skip clusters used by MI (same track twice in AliESDEvent!) |
| Bool_t | fSAUsedEdxInfo | use/not use dE/dx in ITS for assign mass hypothesis |
| Bool_t | fSPDRemoveDeadFlag | Flag saying whether dead pixels should be removed |
| Bool_t | fSPDRemoveNoisyFlag | Flag saying whether noisy pixels should be removed |
| Bool_t | fScaleDTBySin2T | scale Dtheta by 1/sin^2(theta) |
| Bool_t | fSearchForExtras | swicth yes/no for the search of extra-clusters in RefitInward step |
| Bool_t | fSelectBestMIP03 | (MI) Multiply norm chi2 by interpolated one in hypthesis analysis |
| Double_t | fSigmaXDeadZoneHit2 | x error virtual cls |
| Double_t | fSigmaXV | x |
| Double_t | fSigmaY2[6] | y |
| Double_t | fSigmaYV | y |
| Double_t | fSigmaZ2[6] | z |
| Double_t | fSigmaZDeadZoneHit2 | z error virtual cls |
| Double_t | fSigmaZV | z |
| Bool_t | fSkipSubdetsNotInTriggerCluster | skip the subdetectors that are not in the trigger cluster |
| Double_t | fStepSizeTGeo | step size (cm) |
| Bool_t | fStoreLikeSignV0s | flag to store like-sign V0s (MI) |
| Bool_t | fSwitchOffStdSearchClusPlaneEff | if kTRUE,use fNSigXSearchClusterPlaneEff and fDistXSearchClusterPlaneEff |
| Bool_t | fSwitchOnMaxDistNSigFrmBndPlaneEff | if kTRUE,use max(fDistXFromBoundaryPlaneEff,fNSigXFromBoundaryPlaneEff) to accept tracks |
| Bool_t | fSwitchOnMaxDistNSigSrhClusPlaneEff | if kTRUE,use max(fDistXSearchClusterPlaneEff,fNSigXSearchClusterPlaneEff) to accept tracks |
| Float_t | fTanLorentzAngleElectronsSSD | tan(angle) for electrons in SSD @ B = 0.5 T |
| Float_t | fTanLorentzAngleHolesSPD | angle for holes in SPD |
| Float_t | fTanLorentzAngleHolesSSD | tan(angle) for holes in SSD @ B = 0.5 T |
| TString | TNamed::fTitle | object title |
| Int_t | fTracker | ITS tracker to be used (see AliITSReconstructor) |
| Bool_t | fTrackleterBuildCl2TrkRefs | build cluster to track references in AliMultiplicity |
| Float_t | fTrackleterNStdDev | cut on the number of standard deviations |
| Float_t | fTrackleterPhiOverlapCut | Fiducial window in phi for overlap cut |
| Float_t | fTrackleterPhiRotationAngle | Angle to rotate cluster in the SPD inner layer for combinatorial reco only |
| Float_t | fTrackleterPhiShift | Phi shift reference value (at 0.5 T) |
| Float_t | fTrackleterPhiWindow | Search window in phi |
| Float_t | fTrackleterPhiWindowL1 | Search window in phi for inner layer (1) (SPD PlaneEff using tracklets) |
| Float_t | fTrackleterPhiWindowL2 | Search window in phi for outer layer (2) (SPD PlaneEff using tracklets) |
| Bool_t | fTrackleterRemoveClustersFromOverlaps | Option to skip clusters in the overlaps |
| Bool_t | fTrackleterStoreSPD2SingleCl | request storing of L2 singles |
| Float_t | fTrackleterThetaWindow | Search window in theta |
| Float_t | fTrackleterZetaOverlapCut | Fiducial window in eta for overlap cut |
| Float_t | fTrackleterZetaWindowL1 | Search window in zeta for inner layer (1) (SPD PlaneEff using tracklets) |
| Float_t | fTrackleterZetaWindowL2 | Search window in zeta for outer layer (2) (SPD PlaneEff using tracklets) |
| Bool_t | fUpdateOncePerEventPlaneEff | option to update chip efficiency once/event (to avoid doubles) |
| Bool_t | fUseAmplitudeInfo[6] | use cluster charge in cluster-track matching (SDD,SSD) (MI) |
| Bool_t | fUseBadChannelsInClusterFinderSSD | flag to switch on bad channels in CF SSD |
| Bool_t | fUseBadZonesFromOCDB | enable using OCDB info on dead modules and chips (MI) |
| Bool_t | fUseChargeMatchingInClusterFinderSSD | SSD |
| Bool_t | fUseCosmicRunShiftsSSD | SSD time shifts for cosmic run 2007/2008 (use for data taken up to 18 sept 2008) |
| Bool_t | fUseImproveKalman | (MI) Use ImproveKalman version of AliITSTrackV2 instead of Improve |
| Bool_t | fUseSDDClusterSizeSelection | cut on SDD cluster size |
| Bool_t | fUseSDDCorrectionMaps | flag for use of SDD maps in C.F. |
| Bool_t | fUseSingleBadChannelsFromOCDB | enable using OCDB info on bad single SPD pixels and SDD anodes (MI) |
| Int_t | fUseTGeoInTracker | use TGeo to get material budget in tracker MI |
| Bool_t | fUseTrackletsPlaneEff | flag to enable estimate of SPD PlaneEfficiency using tracklets |
| Bool_t | fUseUnfoldingInClusterFinderSDD | SDD |
| Bool_t | fUseUnfoldingInClusterFinderSPD | SPD |
| Bool_t | fUseUnfoldingInClusterFinderSSD | SSD |
| Double_t | fVertexChi2CutPlaneEff | and also with a cut on the chi2 |
| Double_t | fVertexCut | (V2) |
| Int_t | fVertexer | ITS vertexer to be used (see AliITSReconstructor) |
| Float_t | fVertexerFastSmearX | gaussian sigma for x MC vertex smearing |
| Float_t | fVertexerFastSmearY | gaussian sigma for y MC vertex smearing |
| Float_t | fVertexerFastSmearZ | gaussian sigma for z MC vertex smearing |
| Float_t | fVtxr3DDCACut | cut on tracklet-to-tracklet DCA in vertexer3D |
| UChar_t | fVtxr3DHighMultAlgo | downscaling if 0 - traces if 1 |
| Float_t | fVtxr3DPhiCutLoose | loose deltaPhi cut to define tracklets in vertexer 3D |
| Float_t | fVtxr3DPhiCutTight | tight deltaPhi cut to define tracklets in vertexer 3D |
| Int_t | fVtxr3DPileupAlgo | pileup algorithm (0 = VtxZ, 1 = 3D - 2 step, 2 = 3D all in once) |
| Float_t | fVtxr3DRCutNarrow | R extension of the narrow fiducial region for vertexer 3D |
| Float_t | fVtxr3DRCutWide | R extension of the wide fiducial region for vertexer 3D |
| Float_t | fVtxr3DZCutNarrow | Z extension of the narrow fiducial region for vertexer 3D |
| Float_t | fVtxr3DZCutWide | Z extension of the wide fiducial region for vertexer 3D |
| Double_t | fXPassDeadZoneHits | x distance between clusters |
| Double_t | fXV | x |
| Double_t | fYV | y |
| Double_t | fZV | z |
| Double_t | fZWindowDeadZone | window size |
| static const Double_t | fgkBoundaryWidth | to define track at detector boundary |
| static const Double_t | fgkDeltaXNeighbDets | max difference in radius between neighbouring detectors |
| static const Int_t | fgkLastLayerToTrackTo | innermost layer |
| static const Int_t | fgkLayersNotToSkip[6] | array with layers not to skip |
| static const Int_t | fgkMaxDetectorPerLayer | max clusters per layer |
| static const Double_t | fgkSPDdetxlength | SPD ladder length in x (=1.410-2*0.056) |
| static const Double_t | fgkSPDdetzlength | SPD ladder length in z (=7.072-2*0.056) |
| static const Double_t | fgkX0Air | air X0 |
| static const Double_t | fgkX0Be | Berillium X0 |
| static const Double_t | fgkX0cd | TPC central drum X0 |
| static const Double_t | fgkX0iw | TPC inner wall X0 |
| static const Double_t | fgkX0shield[2] | SPD (0) SDD (1) shield X0 |
| static const Double_t | fgkdPipe | pipe x/X0 |
| static const Double_t | fgkdcd | TPC central drum x/X0 |
| static const Double_t | fgkdiw | TPC inner wall x/X0 |
| static const Double_t | fgkdm | TPC membrane x/X0 |
| static const Double_t | fgkdr | TPC rods x/X0 |
| static const Double_t | fgkds | ITS screed x/X0 |
| static const Double_t | fgkdshield[2] | SPD (0) SDD (1) shield x/X0 |
| static const Double_t | fgkrInsideITSscreen | inside ITS screen radius |
| static const Double_t | fgkrInsidePipe | inside pipe radius |
| static const Double_t | fgkrInsideSPD1 | inside SPD1 radius |
| static const Double_t | fgkrInsideShield[2] | inside SPD (0) SDD (1) shield radius |
| static const Double_t | fgkrOutsidePipe | outside pipe radius |
| static const Double_t | fgkrOutsideShield[2] | outside SPD (0) SDD (1) shield radius |
| static const Double_t | fgkrPipe | pipe radius |
| static const Double_t | fgkrcd | TPC central drum radius |
| static const Double_t | fgkriw | TPC inner wall radius |
| static const Double_t | fgkrs | ITS screen radius |
| static const Double_t | fgkyr | TPC rods y (tracking c.s.) |
| static const Double_t | fgkzm | TPC membrane z |
private:
| AliESDV0Params* | fESDV0Params | declare the AliESDV0Params to be able to used in AliITSV0Finder |
Class Charts
| Inheritance Chart: | ||||||||||||
|
Function documentation
AliITSRecoParam * GetPlaneEffParam(Int_t i)
make special reconstruction parameters for Plane Efficiency study on layer i (0,5) if i=-1, then the evaluation for both pixel layers is tried with the tracklet method
Bool_t SetOptReco(TString r)
Set option for local reconstruction. The string must contain at least one of the following substrings: "All", "SPD", "SDD", "SSD"
void SetVertexerSmearMC(Float_t smearx = 0.005, Float_t smeary = 0.005, Float_t smearz = 0.01)
void SetVertexer3DFiducialRegions(Float_t dzwid = 40.0, Float_t drwid = 2.5, Float_t dznar = 0.5, Float_t drnar = 0.5)
SetVertexer3DWideFiducialRegion(Float_t dz = 40.0, Float_t dr = 2.5)
SetVertexer3DNarrowFiducialRegion(Float_t dz = 0.5, Float_t dr = 0.5)
void SetVertexer3DDeltaPhiCuts(Float_t dphiloose = 0.5, Float_t dphitight = 0.025)
void SetVertexer3DDCACut(Float_t dca = 0.1)
void SetVertexer3DDefaults()
void SetAddVirtualClustersInDeadZone(Bool_t add = kTRUE)
{ fAddVirtualClustersInDeadZone=add; return; }void SetSkipSubdetsNotInTriggerCluster(Bool_t flag = kTRUE)
{ fSkipSubdetsNotInTriggerCluster=flag; }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; }Bool_t GetUseAmplitudeInfo(Int_t ilay) const
Option for Plane Efficiency evaluation
{ return fUseAmplitudeInfo[ilay]; }void SetComputePlaneEff(Bool_t eff = kTRUE, Bool_t his = kTRUE)
{ fComputePlaneEff=eff; fHistoPlaneEff=his; return; }void SetOptTrackletsPlaneEff(Bool_t mc = kFALSE, Bool_t bkg = kFALSE)
{fMCTrackletsPlaneEff=mc;fBkgTrackletsPlaneEff=bkg; return;}void SetIPlanePlaneEff(Int_t i = 0)
{if(i<-1 || i>=AliITSgeomTGeo::kNLayers) return; fIPlanePlaneEff=i; }void SetRequireClusterInOuterLayerPlaneEff(Bool_t out = kTRUE)
void SetRequireClusterInInnerLayerPlaneEff(Bool_t in = kTRUE)
void SetNSigXFromBoundaryPlaneEff(Double_t nsigx = 0.)
{if(nsigx<0.)fNSigXFromBoundaryPlaneEff=TMath::Abs(nsigx);else fNSigXFromBoundaryPlaneEff=nsigx;}void SetNSigZFromBoundaryPlaneEff(Double_t nsigz = 0.)
{if(nsigz<0.)fNSigZFromBoundaryPlaneEff=TMath::Abs(nsigz);else fNSigZFromBoundaryPlaneEff=nsigz;}void SetDistXFromBoundaryPlaneEff(Double_t distx = 0.)
{if(distx<0.)fDistXFromBoundaryPlaneEff=TMath::Abs(distx);else fDistXFromBoundaryPlaneEff=distx;}void SetDistZFromBoundaryPlaneEff(Double_t distz = 0.)
{if(distz<0.)fDistZFromBoundaryPlaneEff=TMath::Abs(distz);else fDistZFromBoundaryPlaneEff=distz;}void SetSwitchOnMaxDistNSigFrmBndPlaneEff(Bool_t flagbnd = kFALSE)
{fSwitchOnMaxDistNSigFrmBndPlaneEff=flagbnd;}void SetSwitchOffStdSearchClusPlaneEff(Bool_t flagstdclus = kFALSE)
{fSwitchOffStdSearchClusPlaneEff=flagstdclus;}void SetNSigXSearchClusterPlaneEff(Double_t nsigclx = 0.)
{if(nsigclx<0.)fNSigXSearchClusterPlaneEff=TMath::Abs(nsigclx);else fNSigXSearchClusterPlaneEff=nsigclx;}void SetNSigZSearchClusterPlaneEff(Double_t nsigclz = 0.)
{if(nsigclz<0.)fNSigZSearchClusterPlaneEff=TMath::Abs(nsigclz);else fNSigZSearchClusterPlaneEff=nsigclz;}void SetDistXSearchClusterPlaneEff(Double_t distclx = 0.)
{if(distclx<0.)fDistXSearchClusterPlaneEff=TMath::Abs(distclx);else fDistXSearchClusterPlaneEff=distclx;}void SetDistZSearchClusterPlaneEff(Double_t distclz = 0.)
{if(distclz<0.)fDistZSearchClusterPlaneEff=TMath::Abs(distclz);else fDistZSearchClusterPlaneEff=distclz;}void SetSwitchOnMaxDistNSigSrhClusPlaneEff(Bool_t flagbndcl = kFALSE)
{fSwitchOnMaxDistNSigSrhClusPlaneEff=flagbndcl;}void SetAllowProlongationWithEmptyRoad(Bool_t allow = kTRUE)
{ fAllowProlongationWithEmptyRoad=allow; return; }void SetUseSingleBadChannelsFromOCDB(Bool_t use = kTRUE)
{ fUseSingleBadChannelsFromOCDB=use; return; }void SetPhiLimitsSA(Double_t phimin, Double_t phimax)
void SetLambdaLimitsSA(Double_t lambmin, Double_t lambmax)
void SetMaxSPDcontrForSAToUseAllClusters(Int_t contr = 50)
{ fMaxSPDcontrForSAToUseAllClusters=contr; return; }void SetUseUnfoldingInClusterFinderSPD(Bool_t use = kTRUE)
{ fUseUnfoldingInClusterFinderSPD=use; return; }void SetUseUnfoldingInClusterFinderSDD(Bool_t use = kTRUE)
{ fUseUnfoldingInClusterFinderSDD=use; return; }void SetUseUnfoldingInClusterFinderSSD(Bool_t use = kTRUE)
{ fUseUnfoldingInClusterFinderSSD=use; return; }void SetUseBadChannelsInClusterFinderSSD(Bool_t use = kFALSE)
{ fUseBadChannelsInClusterFinderSSD=use; return; }void SetUseChargeMatchingInClusterFinderSSD(Bool_t use = kTRUE)
{ fUseChargeMatchingInClusterFinderSSD=use; return; }Bool_t GetUseChargeMatchingInClusterFinderSSD() const
{ return fUseChargeMatchingInClusterFinderSSD; }void SetTrackleterRemoveClustersFromOverlaps(Bool_t use = kTRUE)
{ fTrackleterRemoveClustersFromOverlaps=use; return; }Bool_t GetTrackleterRemoveClustersFromOverlaps() const
{ return fTrackleterRemoveClustersFromOverlaps; }void SetAlignFilterMinAngleWrtModulePlanes(Float_t min = 0.52)
AliITSRecoParam & operator=(const AliITSRecoParam& param)