#include "AliDetectorRecoParam.h"
#include "AliITSgeomTGeo.h"
+#include "AliESDV0Params.h"
class AliITSRecoParam : public AliDetectorRecoParam
{
void SetVertexerZ() { SetVertexer(1); }
void SetVertexerCosmics() { SetVertexer(2); }
void SetVertexerIons() { SetVertexer(3); }
- void SetVertexerSmearMC() { SetVertexer(4); }
+ 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);} // for injection tests
void SetVertexerFixedOnTED() {SetVertexer(6);} // for injection tests
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 SetClusterFinder(Int_t cf=0) { fClusterFinder=cf; }
void SetClusterFinderV2() { SetClusterFinder(0); }
void SetClusterFinderOrig() { SetClusterFinder(1); }
void SetLandauFitPID() {SetPID(1);}
Int_t GetPID() const {return fPID;}
- void SetVertexer3DFiducialRegions(Float_t dzwid=20.0, Float_t drwid=2.5, Float_t dznar=0.5, Float_t drnar=0.5){
+ 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=20.0, Float_t dr=2.5){
+ 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.01){
+ void SetVertexer3DDeltaPhiCuts(Float_t dphiloose=0.5, Float_t dphitight=0.025){
fVtxr3DPhiCutLoose=dphiloose;
fVtxr3DPhiCutTight=dphitight;
}
SetVertexer3DDeltaPhiCuts();
SetVertexer3DDCACut();
}
+ void SetSPDVertexerPileupAlgoZ(){fVtxr3DPileupAlgo=0;}
+ void SetSPDVertexerPileupAlgo3DTwoSteps(){fVtxr3DPileupAlgo=1;}
+ void SetSPDVertexerPileupAlgo3DOneShot(){fVtxr3DPileupAlgo=2;}
+
Float_t GetVertexer3DWideFiducialRegionZ() const {return fVtxr3DZCutWide;}
Float_t GetVertexer3DWideFiducialRegionR() const {return fVtxr3DRCutWide;}
Float_t GetVertexer3DLooseDeltaPhiCut() const {return fVtxr3DPhiCutLoose;}
Float_t GetVertexer3DTightDeltaPhiCut() const {return fVtxr3DPhiCutTight;}
Float_t GetVertexer3DDCACut() const {return fVtxr3DDCACut;}
-
+ Int_t GetSPDVertexerPileupAlgo() const {return fVtxr3DPileupAlgo;}
Double_t GetSigmaY2(Int_t i) const { return fSigmaY2[i]; }
Double_t GetSigmaZ2(Int_t i) const { return fSigmaZ2[i]; }
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); }
- Float_t GetClusterMisalErrorY(Int_t i) const { return fClusterMisalErrorY[i]; }
- Float_t GetClusterMisalErrorZ(Int_t i) const { return fClusterMisalErrorZ[i]; }
+ 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; }
{ fComputePlaneEff=eff; fHistoPlaneEff=his; return; }
Bool_t GetComputePlaneEff() const { return fComputePlaneEff; }
Bool_t GetHistoPlaneEff() const { return fHistoPlaneEff; }
- void SetIPlanePlaneEff(Int_t i=0) {if(i<0 || i>=AliITSgeomTGeo::kNLayers) return; fIPlanePlaneEff=i; }
+ 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 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 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; }
}
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 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; }
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; }
Bool_t GetUseCosmicRunShiftsSSD() const { return fUseCosmicRunShiftsSSD; }
// SPD Tracklets (D. Elia)
- void SetTrackleterOnlyOneTrackletPerC2(Bool_t use= kTRUE) {fTrackleterOnlyOneTrackletPerC2=use; return; }
- Bool_t GetTrackleterOnlyOneTrackletPerC2() const { return fTrackleterOnlyOneTrackletPerC2; }
void SetTrackleterPhiWindow(Float_t w=0.08) {fTrackleterPhiWindow=w;}
- void SetTrackleterZetaWindow(Float_t w=1.) {fTrackleterZetaWindow=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 GetTrackleterZetaWindow() const {return fTrackleterZetaWindow;}
+ 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;}
Float_t GetTrackleterZetaOverlapCut() const {return fTrackleterZetaOverlapCut;}
//
+ 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/*5deg*/) {fAlignFilterMaxMatchingAngle=max;}
+ void SetAlignFilterMinAngleWrtModulePlanes(Float_t min=0.52/*30deg*/) {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;}
+
+ AliESDV0Params *GetESDV0Params() const {return fESDV0Params;}
+
enum {fgkMaxClusterPerLayer=70000}; //7000*10; // max clusters per layer
enum {fgkMaxClusterPerLayer5=28000};//7000*10*2/5; // max clusters per layer
Int_t fPID; // ITS PID method to be used (see AliITSReconstructor)
+ // SPD 3D Vertexer configuration
Float_t fVtxr3DZCutWide; // Z extension of the wide 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 fVtxr3DPhiCutLoose; // loose deltaPhi cut to define tracklets in vertexer 3D
Float_t fVtxr3DPhiCutTight; // tight deltaPhi cut to define tracklets in vertexer 3D
Float_t fVtxr3DDCACut; // cut on tracklet-to-tracklet DCA in vertexer3D
+ Int_t fVtxr3DPileupAlgo; // pileup algorithm (0 = VtxZ, 1 = 3D - 2 step, 2 = 3D all in once)
Int_t fLayersToSkip[AliITSgeomTGeo::kNLayers]; // array with layers to skip (MI,SA)
Int_t fClusterErrorsParam; // parametrization for cluster errors (MI), see AliITSRecoParam::GetError()
Float_t fClusterMisalErrorY[AliITSgeomTGeo::kNLayers]; // [cm] additional error on cluster Y pos. due to misalignment (MI,SA)
Float_t fClusterMisalErrorZ[AliITSgeomTGeo::kNLayers]; // [cm] additional error on cluster Z pos. due to misalignment (MI,SA)
+ Float_t fClusterMisalErrorYBOn[AliITSgeomTGeo::kNLayers]; // [cm] additional error on cluster Y pos. due to misalignment (MI,SA)
+ Float_t fClusterMisalErrorZBOn[AliITSgeomTGeo::kNLayers]; // [cm] additional error on cluster Z pos. due to misalignment (MI,SA)
Bool_t fUseAmplitudeInfo[AliITSgeomTGeo::kNLayers]; // use cluster charge in cluster-track matching (SDD,SSD) (MI)
// Plane Efficiency evaluation
Bool_t fComputePlaneEff; // flag to enable computation of PlaneEfficiency
Bool_t fHistoPlaneEff; // flag to enable auxiliary PlaneEff histograms (e.g. residual distributions)
- Int_t fIPlanePlaneEff; // index of the plane (in the range [0,5]) to study the efficiency
+ Bool_t fUseTrackletsPlaneEff; // flag to enable estimate of SPD PlaneEfficiency using tracklets
+ Bool_t fMCTrackletsPlaneEff; // flag to enable the use of MC info for corrections (SPD PlaneEff using tracklets)
+ Bool_t fBkgTrackletsPlaneEff; // flag to evaluate background instead of normal use (SPD PlaneEff using tracklets)
+ 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)
+ 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)
+ Int_t fMinContVtxPlaneEff; // min number of contributors to ESD vtx for SPD PlaneEff using tracklets
+ Int_t fIPlanePlaneEff; // index of the plane (in the range [-1,5]) to study the efficiency (-1 ->Tracklets)
Bool_t fReadPlaneEffFromOCDB; // enable initial reading of Plane Eff statistics from OCDB
// The analized events would be used to increase the statistics
Double_t fMinPtPlaneEff; // minimum p_t of the track to be used for Plane Efficiency evaluation
Bool_t fUseSingleBadChannelsFromOCDB; // enable using OCDB info on bad single SPD pixels and SDD anodes (MI)
Float_t fMinFractionOfBadInRoad; // to decide whether to skip the layer (MI)
Bool_t fAllowProlongationWithEmptyRoad; // allow to prolong even if road is empty (MI)
- Int_t fOuterStartLayerSA; // outer ITS layer to start track in SA
+ Int_t fInwardFlagSA; // flag for inward track finding in SA
+ Int_t fOuterStartLayerSA; // outer ITS layer to start track in SA outward
+ Int_t fInnerStartLayerSA; // inner ITS layer to start track in SA inward
+ Int_t fMinNPointsSA; // min. number of ITS clusters for a SA track
Double_t fFactorSAWindowSizes; // larger window sizes in SA
Int_t fNLoopsSA; // number of loops in tracker SA
Double_t fMinPhiSA; // minimum phi value for SA windows
Double_t fMaxPhiSA; // maximum phi value for SA windows
Double_t fMinLambdaSA; // minimum lambda value for SA windows
Double_t fMaxLambdaSA; // maximum lambda value for SA windows
-
+ Float_t fMinClusterChargeSA; // minimum SDD,SSD cluster charge for SA tarcker
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 fFindV0s; // flag to enable V0 finder (MI)
+ Bool_t fStoreLikeSignV0s; // flag to store like-sign V0s (MI)
// cluster unfolding in ITS cluster finders
Bool_t fUseUnfoldingInClusterFinderSPD; // SPD
Bool_t fUseUnfoldingInClusterFinderSDD; // SDD
Bool_t fUseUnfoldingInClusterFinderSSD; // SSD
+ Bool_t fUseBadChannelsInClusterFinderSSD; // flag to switch on bad channels in CF SSD
+
+ Bool_t fUseSDDCorrectionMaps; // flag for use of SDD maps in C.F.
+ Bool_t fUseSDDClusterSizeSelection; // cut on SDD cluster size
+ Float_t fMinClusterChargeSDD; // cut on SDD cluster charge
+
Bool_t fUseChargeMatchingInClusterFinderSSD; // SSD
// SPD Tracklets (D. Elia)
- Bool_t fTrackleterOnlyOneTrackletPerC2; // Allow only one tracklet per cluster in the outer layer
Float_t fTrackleterPhiWindow; // Search window in phi
- Float_t fTrackleterZetaWindow; // Search window in eta
+ Float_t fTrackleterThetaWindow; // Search window in theta
+ Float_t fTrackleterPhiShift; // Phi shift reference value (at 0.5 T)
Bool_t fTrackleterRemoveClustersFromOverlaps; // Option to skip clusters in the overlaps
Float_t fTrackleterPhiOverlapCut; // Fiducial window in phi for overlap cut
Float_t fTrackleterZetaOverlapCut; // Fiducial window in eta for overlap cut
Bool_t fUseCosmicRunShiftsSSD; // SSD time shifts for cosmic run 2007/2008 (use for data taken up to 18 sept 2008)
- ClassDef(AliITSRecoParam,13) // ITS reco parameters
+
+ // SPD flags to specify whether noisy and dead pixels
+ // should be removed at the local reconstruction step (default and safe way is true for both)
+ Bool_t fSPDRemoveNoisyFlag; // Flag saying whether noisy pixels should be removed
+ Bool_t fSPDRemoveDeadFlag; // Flag saying whether dead pixels should be removed
+
+ // VertexerFast configuration
+ 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
+
+ // PWG1/AliAlignmentDataFilterITS configuration
+ Bool_t fAlignFilterCosmics; // flag for cosmics case
+ Bool_t fAlignFilterCosmicMergeTracks; // merge cosmic tracks
+ Int_t fAlignFilterMinITSPoints; // min points per track
+ Int_t fAlignFilterMinITSPointsMerged; // min points for merged tracks
+ Bool_t fAlignFilterOnlyITSSATracks; // only ITS SA tracks
+ Bool_t fAlignFilterOnlyITSTPCTracks; // only ITS+TPC tracks
+ Bool_t fAlignFilterUseLayer[AliITSgeomTGeo::kNLayers]; // layers to use
+ Bool_t fAlignFilterSkipExtra; // no extra cls in array
+ Float_t fAlignFilterMaxMatchingAngle; // matching for cosmics
+ Float_t fAlignFilterMinAngleWrtModulePlanes; // min angle track-to-sensor
+ Float_t fAlignFilterMinPt; // min pt
+ Float_t fAlignFilterMaxPt; // max pt
+ Bool_t fAlignFilterFillQANtuples; // fill QA ntuples
+
+ private:
+ AliESDV0Params * fESDV0Params; // declare the AliESDV0Params to be able to used in AliITSV0Finder
+
+ AliITSRecoParam(const AliITSRecoParam & param);
+ AliITSRecoParam & operator=(const AliITSRecoParam ¶m);
+
+ ClassDef(AliITSRecoParam,26) // ITS reco parameters
};
#endif
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff