Merge branch 'AliceO2Group:dev' into fd3_digits

Author: pkurash

Common/Constants/include/CommonConstants/PhysicsConstants.h

@@ -64,6 +64,9 @@ enum Pdg {
   kJPsi = 443,
   kLambdaB0 = 5122,
   kLambdaCPlus = 4122,
+  kLambdaCPlus2860 = 24124,
+  kLambdaCPlus2880 = 24126,
+  kLambdaCPlus2940 = 4125,
   kOmegaC0 = 4332,
   kK0Star892 = 313,
   kKPlusStar892 = 323,
@@ -131,6 +134,9 @@ constexpr double MassChiC1 = 3.51067;
 constexpr double MassJPsi = 3.0969;
 constexpr double MassLambdaB0 = 5.6196;
 constexpr double MassLambdaCPlus = 2.28646;
+constexpr double MassLambdaCPlus2860 = 2.8561;
+constexpr double MassLambdaCPlus2880 = 2.8816;
+constexpr double MassLambdaCPlus2940 = 2.9396;
 constexpr double MassOmegaC0 = 2.6952;
 constexpr double MassK0Star892 = 0.89555;
 constexpr double MassKPlusStar892 = 0.89167;

Common/Constants/include/CommonConstants/make_pdg_header.py

@@ -122,6 +122,9 @@ class Pdg(Enum):
     kJPsi = 443
     kLambdaB0 = 5122
     kLambdaCPlus = 4122
+    kLambdaCPlus2860 = 24124
+    kLambdaCPlus2880 = 24126
+    kLambdaCPlus2940 = 4125
     kOmegaC0 = 4332
     kK0Star892 = 313
     kKPlusStar892 = 323

DataFormats/Detectors/CTP/src/CTPRateFetcher.cxx

@@ -233,9 +233,7 @@ double CTPRateFetcher::pileUpCorrection(double triggerRate)
   if (mLHCIFdata.getFillNumber() == 0) {
     LOG(fatal) << "No filling" << std::endl;
   }
-  auto bfilling = mLHCIFdata.getBunchFilling();
-  std::vector<int> bcs = bfilling.getFilledBCs();
-  double nbc = bcs.size();
+  double nbc = mLHCIFdata.getBunchFilling().getPattern().count();
   double nTriggersPerFilledBC = triggerRate / nbc / constants::lhc::LHCRevFreq;
   double mu = -std::log(1 - nTriggersPerFilledBC);
   return mu * nbc * constants::lhc::LHCRevFreq;

DataFormats/Detectors/ITSMFT/common/include/DataFormatsITSMFT/TopologyDictionary.h

@@ -92,67 +92,67 @@ class TopologyDictionary
   /// Returns the x position of the COG for the n_th element
   inline float getXCOG(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mXCOG;
   }
   /// Returns the error on the x position of the COG for the n_th element
   inline float getErrX(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mErrX;
   }
   /// Returns the z position of the COG for the n_th element
   inline float getZCOG(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mZCOG;
   }
   /// Returns the error on the z position of the COG for the n_th element
   inline float getErrZ(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mErrZ;
   }
   /// Returns the error^2 on the x position of the COG for the n_th element
   inline float getErr2X(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mErr2X;
   }
   /// Returns the error^2 on the z position of the COG for the n_th element
   inline float getErr2Z(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mErr2Z;
   }
   /// Returns the hash of the n_th element
   inline unsigned long getHash(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mHash;
   }
   /// Returns the number of fired pixels of the n_th element
   inline int getNpixels(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mNpixels;
   }
   /// Returns the frequency of the n_th element;
   inline double getFrequency(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mFrequency;
   }
   /// Returns true if the element corresponds to a group of rare topologies
   inline bool isGroup(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mIsGroup;
   }
   /// Returns the pattern of the topology
   inline const ClusterPattern& getPattern(int n) const
   {
-    assert(n >= 0 || n < (int)mVectorOfIDs.size());
+    assert(n >= 0 && n < (int)mVectorOfIDs.size());
     return mVectorOfIDs[n].mPattern;
   }
 

DataFormats/Reconstruction/include/ReconstructionDataFormats/DCA.h

@@ -54,13 +54,25 @@ class DCA
     mZ = z;
   }
 
+  GPUd() void setY(float y) { mY = y; }
+  GPUd() void setZ(float z) { mZ = z; }
+  GPUd() void setSigmaY2(float v) { mCov[0] = v; }
+  GPUd() void setSigmaYZ(float v) { mCov[1] = v; }
+  GPUd() void setSigmaZ2(float v) { mCov[2] = v; }
+  GPUd() void addCov(const std::array<float, 3>& vadd)
+  {
+    mCov[0] += vadd[0];
+    mCov[1] += vadd[1];
+    mCov[2] += vadd[2];
+  }
   GPUd() auto getY() const { return mY; }
   GPUd() auto getZ() const { return mZ; }
   GPUd() auto getR2() const { return mY * mY + mZ * mZ; }
   GPUd() auto getSigmaY2() const { return mCov[0]; }
   GPUd() auto getSigmaYZ() const { return mCov[1]; }
   GPUd() auto getSigmaZ2() const { return mCov[2]; }
   GPUd() const auto& getCovariance() const { return mCov; }
+  GPUd() float calcChi2() const;
 
   void print() const;
 

DataFormats/Reconstruction/include/ReconstructionDataFormats/VtxTrackRef.h

@@ -80,12 +80,17 @@ class VtxTrackRef : public RangeReference<int, int>
   // set the last +1 element index and finalize all references
   void setEnd(int end);
 
+  const RangeReference<int, int>& getITSGloContributors() const { return mITSGloContributors; }
+  RangeReference<int, int>& getITSGloContributors() { return mITSGloContributors; }
+
  private:
   using RangeReference<int, int>::RangeReference;
   int mVtxID = -1; // vertex ID. The reference for unassigned tracks will have it negative!
   std::array<int, VtxTrackIndex::Source::NSources - 1> mFirstEntrySource{0};
 
-  ClassDefNV(VtxTrackRef, 2);
+  RangeReference<int, int> mITSGloContributors; // optionally filled to keep ITS parts of all contributors (including ITS-only ones)
+
+  ClassDefNV(VtxTrackRef, 3);
 };
 
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::VtxTrackRef& v);

DataFormats/Reconstruction/src/DCA.cxx

@@ -9,6 +9,8 @@
 // granted to it by virtue of its status as an Intergovernmental Organization
 // or submit itself to any jurisdiction.
 
+#include "GPUCommonMath.h"
+#include "CommonConstants/MathConstants.h"
 #include "ReconstructionDataFormats/DCA.h"
 #include <iostream>
 
@@ -20,6 +22,16 @@ namespace o2
 namespace dataformats
 {
 
+float DCA::calcChi2() const
+{
+  // Estimate the chi2 for DCA
+  const auto sdd = mCov[0], sdz = mCov[1], szz = mCov[2], det = sdd * szz - sdz * sdz;
+  if (o2::gpu::CAMath::Abs(det) < o2::constants::math::Almost0) {
+    return constants::math::VeryBig;
+  }
+  return (mY * (szz * mY - sdz * mZ) + mZ * (sdd * mZ - mY * sdz)) / det;
+}
+
 std::ostream& operator<<(std::ostream& os, const o2::dataformats::DCA& d)
 {
   // stream itself

DataFormats/Reconstruction/src/VtxTrackRef.cxx

@@ -31,6 +31,9 @@ std::string VtxTrackRef::asString(bool skipEmpty) const
       str += fmt::format(", N{:s} : {:d}", VtxTrackIndex::getSourceName(i), getEntriesOfSource(i));
     }
   }
+  if (mITSGloContributors.getEntries()) {
+    str += fmt::format("| ITScontributors: {} from {}", mITSGloContributors.getEntries(), mITSGloContributors.getFirstEntry());
+  }
   return str;
 }
 

Detectors/GlobalTracking/include/GlobalTracking/MatchCosmics.h

@@ -83,13 +83,16 @@ class MatchCosmics
     TBracket tBracket;      ///< bracketing time-bins
     GTrackID origID;        ///< track origin id
     int matchID = MinusOne; ///< entry (none if MinusOne) of its match in the vector of matches
+    short vtIDMin = -1;     ///< id of the 1st compatible vertex
+    short vtIDMax = -1;     ///< id of the last compatible vertex
   };
   void setTPCCorrMaps(const o2::gpu::TPCFastTransformPOD* maph);
   void setTPCVDrift(const o2::tpc::VDriftCorrFact& v);
   void setITSROFrameLengthMUS(float fums) { mITSROFrameLengthMUS = fums; }
   void setITSDict(const o2::itsmft::TopologyDictionary* dict) { mITSDict = dict; }
   void process(const o2::globaltracking::RecoContainer& data);
   void setUseMC(bool mc) { mUseMC = mc; }
+  void setUsePVInfo(bool v) { mUsePVInfo = v; }
   void init();
   void end();
 
@@ -146,6 +149,7 @@ class MatchCosmics
   float mTPCTBinMUS = 0.;         ///< TPC time bin duration in microseconds
   float mBz = 0;                  ///< nominal Bz
   bool mFieldON = true;
+  bool mUsePVInfo = false;
   bool mUseMC = true;
   float mITSROFrameLengthMUS = 0.;
   float mQ2PtCutoff = 1e9;

Detectors/GlobalTracking/include/GlobalTracking/MatchCosmicsParams.h

@@ -17,22 +17,28 @@
 #include "CommonUtils/ConfigurableParam.h"
 #include "CommonUtils/ConfigurableParamHelper.h"
 #include "DetectorsBase/Propagator.h"
+#include "ReconstructionDataFormats/GlobalTrackID.h"
 
 namespace o2
 {
 namespace globaltracking
 {
 
 struct MatchCosmicsParams : public o2::conf::ConfigurableParamHelper<MatchCosmicsParams> {
+  float dcaCutChi2[o2::dataformats::GlobalTrackID::NSources] = {};           // optional (>0) chi2 cut on track DCA to any of its compatible vertices
   float systSigma2[o2::track::kNParams] = {0.01f, 0.01f, 1e-4f, 1e-4f, 0.f}; // extra error to be added at legs comparison
   float crudeNSigma2Cut[o2::track::kNParams] = {49.f, 49.f, 49.f, 49.f, 49.f};
-  float crudeChi2Cut = 999.;
-  float timeToleranceMUS = 0.;
-  float maxStep = 10.;
-  float maxSnp = 0.99;
-  float minSeedPt = 0.10;  // use only tracks above this pT (scaled with field)
-  float nSigmaTError = 4.; // number of sigmas on track time error for matching (except for TPC which provides an interval)
+  float crudeChi2Cut = 999.f;
+  float timeToleranceMUS = 0.f;
+  float maxStep = 10.f;
+  float maxSnp = 0.99f;
+  float minSeedPt = 0.10f;     // use only tracks above this pT (scaled with field)
+  float nSigmaTError = 4.f;    // number of sigmas on track time error for matching (except for TPC which provides an interval)
+  float tpcExtraZError2 = 1.f; // extra error^2 on the TPC-only track Z coordinate
+  float fiducialRIP = 1.0f;    // consider track having |Y@x=0|< this as passing DCA cut (if requested)
+  float fiducialZIP = 20.f;    // consider track having |Z@x=0|< this as passing DCA cut (if requested)
   bool allowTPCOnly = true;
+  bool discardPVContributors = true; // used only if the global option --use-pv-info is requested
   o2::base::Propagator::MatCorrType matCorr = o2::base::Propagator::MatCorrType::USEMatCorrLUT;
 
   O2ParamDef(MatchCosmicsParams, "cosmicsMatch");