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;
}
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<0 || i>=AliITSgeomTGeo::kNLayers) return; fIPlanePlaneEff=i; }
+ 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 SetUseUnfoldingInClusterFinderSSD(Bool_t use=kTRUE) { fUseUnfoldingInClusterFinderSSD=use; return; }
Bool_t GetUseUnfoldingInClusterFinderSSD() const { return fUseUnfoldingInClusterFinderSSD; }
+ 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 GetTrackleterZetaOverlapCut() const {return fTrackleterZetaOverlapCut;}
//
-
void SetSPDRemoveNoisyFlag(Bool_t value) {fSPDRemoveNoisyFlag = value;}
- Bool_t GetSPDRemoveNoisyFlag() {return fSPDRemoveNoisyFlag;}
+ Bool_t GetSPDRemoveNoisyFlag() const {return fSPDRemoveNoisyFlag;}
void SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;}
- Bool_t GetSPDRemoveDeadFlag() {return fSPDRemoveDeadFlag;}
+ 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;}
+
+
+
enum {fgkMaxClusterPerLayer=70000}; //7000*10; // max clusters per layer
enum {fgkMaxClusterPerLayer5=28000};//7000*10*2/5; // max clusters per layer
enum {fgkMaxClusterPerLayer10=14000};//7000*10*2/10; // max clusters per layer
Float_t fTrackleterZetaWindowL1; // Search window in zeta for inner layer (1) (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 [0,5]) to study the efficiency
+ 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 fUseUnfoldingInClusterFinderSDD; // SDD
Bool_t fUseUnfoldingInClusterFinderSSD; // 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
// 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
-
- ClassDef(AliITSRecoParam,18) // ITS reco parameters
+ // 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
+
+
+ ClassDef(AliITSRecoParam,21) // ITS reco parameters
};
#endif