#include "AliDetectorRecoParam.h"
#include "AliITSgeomTGeo.h"
+#include "AliESDV0Params.h"
class AliITSRecoParam : public AliDetectorRecoParam
{
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; }
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<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 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 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() {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;}
+
+ 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
enum {fgkMaxClusterPerLayer10=14000};//7000*10*2/10; // 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)
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 [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 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
Float_t fVertexerFastSmearY; // gaussian sigma for y MC vertex smearing
Float_t fVertexerFastSmearZ; // gaussian sigma for z MC vertex smearing
-
- ClassDef(AliITSRecoParam,20) // ITS reco parameters
+ // 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