SVertexerParams.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
 
 
#ifndef ALICEO2_SVERTEXER_PARAMS_H
#define ALICEO2_SVERTEXER_PARAMS_H
 
#include "CommonUtils/ConfigurableParam.h"
#include "CommonUtils/ConfigurableParamHelper.h"
#include "DetectorsVertexing/SVertexHypothesis.h"
#include "DetectorsBase/Propagator.h"
 
namespace o2
{
namespace vertexing
{
 
// These are configurable params for Primary Vertexer
struct SVertexerParams : public o2::conf::ConfigurableParamHelper<SVertexerParams> {
 
  // parameters
  bool createFullV0s = false;      
  bool createFullCascades = false; 
  bool createFull3Bodies = false;  
 
  bool useAbsDCA = true;        
  bool selectBestV0 = false;    
  float maxChi2 = 2.;           
  float minParamChange = 1e-3;  
  float minRelChi2Change = 0.9; 
  float maxDZIni = 5.;          
  float maxDXYIni = 4.;         
  float maxRIni = 150;          
  //
  // propagation options
  int matCorr = int(o2::base::Propagator::MatCorrType::USEMatCorrNONE); 
  float minRFor3DField = 40;                                            
  float maxStep = 2.;                                                   
  float maxSnp = 0.95;                                                  
  float minXSeed = -1.;                                                 
  bool usePropagator = false;                                           
  bool refitWithMatCorr = false;                                        
  //
  int maxPVContributors = 2;              
  float minDCAToPV = 0.05;                
  float minRToMeanVertex = 0.5;           
  float maxDCAXYToMeanVertex = 0.2;       
  float maxDCAXYToMeanVertexV0Casc = 2.;  
  float maxDCAXYToMeanVertex3bodyV0 = 2.; 
  float minPtV0 = 0.01;                   
  float minPtV0FromCascade = 0.3;         
  float maxTglV0 = 2.;                    
 
  float causalityRTolerance = 1.; 
  float maxV0ToProngsRDiff = 50.; 
 
  float minCosPAXYMeanVertex = 0.95;       
  float minCosPAXYMeanVertexCascV0 = 0.8;  
  float minCosPAXYMeanVertex3bodyV0 = 0.9; 
 
  float maxRToMeanVertexCascV0 = 80; // don't consider as a cascade V0 seed if above this R
  float minCosPACascV0 = 0.8;        // min cos of pointing angle to PV for cascade V0 candidates
  float minCosPA3bodyV0 = 0.8;       // min cos of PA to PV for 3body V0
  float minCosPA = 0.9;              
 
  float minRDiffV0Casc = 0.2; 
  float maxRDiffV03body = 3;  
  float maxRIniCasc = 90.;    // don't consider as a cascade seed (circles/line intersection) if its R exceeds this
 
  float maxDCAXYCasc = 0.3;  // max DCA of cascade to PV in XY // TODO RS: shall we use real chi2 to vertex?
  float maxDCAZCasc = 0.3;   // max DCA of cascade to PV in Z
  float maxDCAXY3Body = 0.5; // max DCA of 3 body decay to PV in XY // TODO RS: shall we use real chi2 to vertex?
  float maxDCAZ3Body = 1.;   // max DCA of 3 body decay to PV in Z
  float minCosPACasc = 0.7;  // min cos of PA to PV for cascade candidates
  float minCosPA3body = 0.8; // min cos of PA to PV for 3body decay candidates
  float minPtCasc = 0.01;    // cascade minimum pT
  float maxTglCasc = 2.;     // maximum tgLambda of cascade
  float minPt3Body = 0.01;   // minimum pT of 3body V0
  float maxTgl3Body = 2.;    // maximum tgLambda of 3body V0
 
  float maxRIni3body = 90.; // don't consider as a 3body seed (circles/line intersection) if its R exceeds this
 
  // Cuts for TPC only tracks
  bool mExcludeTPCtracks = false;            // don't loop over TPC tracks if true (if loaded, dEdx info is used instead)
  float mTPCTrackMaxX = -1.;                 // don't use TPC standalone tracks with X exceeding this;
  float mTPCTrack2Beam = 21.f;               // straight line for TPC track back to beamline
  bool mTPCTrackPhotonTune = true;           // use TPC-only photon tuning
  int mTPCTrackMinNClusters = -1;            // minimum number of clusters
  float mTPCTrackXY2Radius = 90.f;           // check for realistic conversion point, e.g., in material
  float mTPCTrackD2R = 4.f;                  // check for maximal distance of pairs and their radii
  float mTPCTrackDR = 90.f;                  // check if preliminary conversion point can lie somewhere reasonable
  float minTPCdEdx = 250;                    // starting from this dEdx value, tracks with p > minMomTPCdEdx are always accepted
  float minMomTPCdEdx = 0.8;                 // minimum p for tracks with dEdx > mMinTPCdEdx to be accepted
  float maxV0TglAbsDiff = 0.3;               
  float mTPCTrackMaxChi2 = 4.;               
  float mTPCTrackMaxDZIni = 8.;              
  float mTPCTrackMaxDXYIni = 8.;             
  float mTPCTrackMaxDCAXY2ToMeanVertex = 2.; 
 
  uint8_t mITSSAminNclu = 6;             // global requirement of at least this many ITS clusters if no TPC info present (N.B.: affects all secondary vertexing)
  uint8_t mITSSAminNcluCascades = 6;     // require at least this many ITS clusters if no TPC info present for cascade finding.
  bool mRejectITSonlyOBtrack = false;    // reject tracks in OB with 4 hits (keep false for more low pt conversions)
  bool mRequireTPCforCascBaryons = true; // require that baryon daughter of cascade has TPC
  bool mSkipTPCOnlyCascade = true;       // skip TPC only tracks when doing cascade finding
  bool mSkipTPCOnly3Body = true;         // skip TPC only tracks when doing cascade finding
 
  // percent deviation from expected proton dEdx - to be replaced - estimated sigma from TPC for now 6%; a 6*sigma cut is therefore 36% = 0.36f. Any value above 1.0f will be ignored manually when checking.
  float mFractiondEdxforCascBaryons = 2.f; // 0.36f;
  // default: average 2023 from C. Sonnabend, Nov 2023: ([0.217553   4.02762    0.00850178 2.33324    0.880904  ])
  // to-do: grab from CCDB when available -> discussion with TPC experts, not available yet
  float mBBpars[5] = {0.217553, 4.02762, 0.00850178, 2.33324, 0.880904};
 
  // cuts on different V0 PID params
  bool checkV0Hypothesis = true;                                                                                               // enable Mass Hypothesis check
  float pidCutsPhoton[SVertexHypothesis::NPIDParams] = {0.001, 20, 0.10, 20, 0.10, 0.0, 0.0, 0.0, 0.0};                        // Photon
  float pidCutsK0[SVertexHypothesis::NPIDParams] = {0., 20, 0., 5.0, 0.0, 2.84798e-03, 9.84206e-04, 3.31951e-03, 2.39438};     // K0
  float pidCutsLambda[SVertexHypothesis::NPIDParams] = {0., 20, 0., 5.0, 0.0, 1.09004e-03, 2.62291e-04, 8.93179e-03, 2.83121}; // Lambda
  float pidCutsHTriton[SVertexHypothesis::NPIDParams] = {0.0025, 14, 0.07, 14, 0.0, 0.5, 0.0, 0.0, 0.0};                       // HyperTriton
  float pidCutsHhydrog4[SVertexHypothesis::NPIDParams] = {0.0025, 14, 0.07, 14, 0.0, 0.5, 0.0, 0.0, 0.0};                      // Hyperhydrog4 - Need to update
  //
  // cuts on different Cascade PID params
  bool checkCascadeHypothesis = true;
  float pidCutsXiMinus[SVertexHypothesis::NPIDParams] = {0.0, 15, 0.01, 4.0, 0.0, 1.56315e-03, 2.23279e-04, 2.75136e-02, 3.309};          // XiMinus
  float pidCutsOmegaMinus[SVertexHypothesis::NPIDParams] = {0.0, 15, 0.01, 4.0, 0.0, 1.43572e-03, 6.94416e-04, 2.13534e+05, 1.48889e+01}; // OmegaMinus
  float maximalCascadeWidth = 0.006;
  //
  // cuts on different 3 body PID params
  bool check3bodyHypothesis = true;
  float pidCutsH3L3body[SVertex3Hypothesis::NPIDParams] = {0.0025, 14, 0.07, 0.5};  // H3L -> d p pi-
  float pidCutsH4L3body[SVertex3Hypothesis::NPIDParams] = {0.0025, 14, 0.07, 0.5};  // H4L -> t p pi-
  float pidCutsHe4L3body[SVertex3Hypothesis::NPIDParams] = {0.0025, 14, 0.07, 0.5}; // He4L -> He3 p pi-
  float pidCutsHe5L3body[SVertex3Hypothesis::NPIDParams] = {0.0025, 14, 0.07, 0.5}; // He5L -> He4 p pi-
 
  O2ParamDef(SVertexerParams, "svertexer");
};
} // namespace vertexing
 
namespace framework
{
template <typename T>
struct is_messageable;
template <>
struct is_messageable<o2::vertexing::SVertexerParams> : std::true_type {
};
} // namespace framework
 
} // end namespace o2
 
#endif