Merge branch 'AliceO2Group:dev' into new-detector4

Author: pkurash

Common/ML/include/ML/OrtInterface.h

@@ -116,7 +116,7 @@ class OrtModel
   int32_t mInputsTotal = 0, mOutputsTotal = 0;                                                        // Total number of inputs and outputs
 
   // Environment settings
-  bool mInitialized = false;
+  bool mInitialized = false, mDeterministicMode = false;
   std::string mModelPath, mEnvName = "", mDeviceType = "CPU", mThreadAffinity = ""; // device options should be cpu, rocm, migraphx, cuda
   int32_t mIntraOpNumThreads = 1, mInterOpNumThreads = 1, mDeviceId = -1, mEnableProfiling = 0, mLoggingLevel = 0, mAllocateDeviceMemory = 0, mEnableOptimizations = 0;
 

Common/ML/src/OrtInterface.cxx

@@ -68,6 +68,7 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
     mEnableProfiling = (optionsMap.contains("enable-profiling") ? std::stoi(optionsMap["enable-profiling"]) : 0);
     mEnableOptimizations = (optionsMap.contains("enable-optimizations") ? std::stoi(optionsMap["enable-optimizations"]) : 0);
     mEnvName = (optionsMap.contains("onnx-environment-name") ? optionsMap["onnx-environment-name"] : "onnx_model_inference");
+    mDeterministicMode = (optionsMap.contains("deterministic-compute") ? std::stoi(optionsMap["deterministic-compute"]) : 0);
 
     if (mDeviceType == "CPU") {
       (mPImplOrt->sessionOptions).SetIntraOpNumThreads(mIntraOpNumThreads);
@@ -99,6 +100,10 @@ void OrtModel::initOptions(std::unordered_map<std::string, std::string> optionsM
       (mPImplOrt->sessionOptions).DisableProfiling();
     }
 
+    if (mDeterministicMode > 0) {
+      (mPImplOrt->sessionOptions).AddConfigEntry("session_options.use_deterministic_compute", "1");
+    }
+
     (mPImplOrt->sessionOptions).SetGraphOptimizationLevel(GraphOptimizationLevel(mEnableOptimizations));
     (mPImplOrt->sessionOptions).SetLogSeverityLevel(OrtLoggingLevel(mLoggingLevel));
 

DataFormats/Detectors/TOF/CMakeLists.txt

@@ -16,7 +16,6 @@ o2_add_library(DataFormatsTOF
                        src/CalibLHCphaseTOF.cxx
                        src/CalibTimeSlewingParamTOF.cxx
                        src/CTF.cxx
-                       src/ParameterContainers.cxx
                        src/CalibInfoCluster.cxx
                        src/CosmicInfo.cxx
                        src/Diagnostic.cxx

DataFormats/Detectors/TOF/include/DataFormatsTOF/ParameterContainers.h

@@ -37,7 +37,7 @@ class Parameters
   Parameters(std::array<std::string, nPar> parNames, std::string name) : mName{name}, mPar{}, mParNames{parNames} {};
 
   /// Default destructor
-  ~Parameters() = default;
+  virtual ~Parameters() = default; // Ensure proper cleanup in derived classes
 
   /// Setter for the parameter at position iparam
   /// \param iparam index in the array of the parameters
@@ -183,10 +183,27 @@ class ParameterCollection : public TNamed
   /// @param value parameter to add to the stored information
   /// @param pass key to look for in the stored information e.g. pass
   /// @return true if found and configured false if not fully configured
-  bool addParameter(const std::string& pass, const std::string& parName, float value);
+  bool addParameter(const std::string& pass, const std::string& parName, float value)
+  {
+    const bool alreadyPresent = hasKey(pass);
+    if (alreadyPresent) {
+      LOG(debug) << "Changing parametrization corresponding to key " << pass << " from size " << mParameters[pass].size() << " to " << parName;
+    } else {
+      mParameters[pass] = std::unordered_map<std::string, paramvar_t>{};
+      LOG(debug) << "Adding new parametrization corresponding to key " << pass << ": " << parName;
+    }
+    mParameters[pass][parName] = value;
+    return true;
+  }
 
   /// @return the size of the container i.e. the number of stored keys (or passes)
-  int getSize(const std::string& pass) const;
+  int getSize(const std::string& pass) const
+  {
+    if (!hasKey(pass)) {
+      return -1;
+    }
+    return mParameters.at(pass).size();
+  }
 
   /// @brief Function to push the parameters from the sub container into the collection and store it under a given key
   /// @tparam ParType type of the parameter container
@@ -214,10 +231,26 @@ class ParameterCollection : public TNamed
 
   /// @brief printing function for the content of the pass
   /// @param pass pass to print
-  void print(const std::string& pass) const;
+  void print(const std::string& pass) const
+  {
+    const auto& size = getSize(pass);
+    if (size < 0) {
+      LOG(info) << "empty pass: " << pass;
+      return;
+    }
+    LOG(info) << "Pass \"" << pass << "\" with size " << size;
+    for (const auto& [par, value] : mParameters.at(pass)) {
+      LOG(info) << "par name = " << par << ", value = " << value;
+    }
+  }
 
   /// @brief printing function for the full content of the container
-  void print() const;
+  void print() const
+  {
+    for (const auto& [pass, pars] : mParameters) {
+      print(pass);
+    }
+  }
 
   /// @brief Getter of the full map of parameters stored in the container
   /// @return returns the full map of parameters

DataFormats/Detectors/TOF/src/ParameterContainers.cxx

@@ -55,14 +55,19 @@ class DecayNBodyIndex
 class V0Index : public DecayNBodyIndex<2>
 {
  public:
+  enum V0Type : uint8_t {
+    kStandaloneV0 = 0,
+    kPhotonOnly,
+    kCollinear,
+  };
   using DecayNBodyIndex<2>::DecayNBodyIndex;
   V0Index(int v, GIndex p, GIndex n) : DecayNBodyIndex<2>(v, {p, n}) {}
-  bool isStandaloneV0() const { return testBit(0); }
-  bool isPhotonOnly() const { return testBit(1); }
-  bool isCollinear() const { return testBit(2); }
-  void setStandaloneV0() { setBit(0); }
-  void setPhotonOnly() { setBit(1); }
-  void setCollinear() { setBit(2); }
+  bool isStandaloneV0() const { return testBit(kStandaloneV0); }
+  bool isPhotonOnly() const { return testBit(kPhotonOnly); }
+  bool isCollinear() const { return testBit(kCollinear); }
+  void setStandaloneV0() { setBit(kStandaloneV0); }
+  void setPhotonOnly() { setBit(kPhotonOnly); }
+  void setCollinear() { setBit(kCollinear); }
   ClassDefNV(V0Index, 1);
 };
 

DataFormats/Reconstruction/include/ReconstructionDataFormats/DecayNBodyIndex.h

@@ -248,6 +248,8 @@ class TrackParametrization
 #ifndef GPUCA_ALIGPUCODE
   std::string asString() const;
   std::string asStringHexadecimal();
+  size_t hash() const { return hash(getX(), getAlpha(), getY(), getZ(), getSnp(), getTgl(), getQ2Pt()); }
+  static size_t hash(float x, float alp, float y, float z, float snp, float tgl, float q2pt);
 #endif
 
   GPUd() void updateParam(value_t delta, int i);
@@ -752,6 +754,21 @@ GPUdi() void TrackParametrization<value_T>::updateParams(const value_t* delta)
   }
 }
 
+#ifndef GPUCA_ALIGPUCODE
+template <typename value_T>
+size_t TrackParametrization<value_T>::hash(float x, float alp, float y, float z, float snp, float tgl, float q2pt)
+{
+  size_t h = std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(x, 0xFFFFFFF0));
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(alp, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(y, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(z, 0xFFFFFFF0)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(snp, 0xFFFFFF00)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(tgl, 0xFFFFFF00)) << 1;
+  h ^= std::hash<float>{}(o2::math_utils::detail::truncateFloatFraction(q2pt, 0xFFFFFC00)) << 1;
+  return h;
+}
+#endif
+
 } // namespace track
 } // namespace o2
 

DataFormats/Reconstruction/include/ReconstructionDataFormats/TrackParametrization.h

@@ -470,6 +470,15 @@ inline void O2DatabasePDG::addALICEParticles(TDatabasePDG* db)
                     0.185, 0, "Resonance", ionCode);
   }
 
+  // Lambda(1405)0
+  ionCode = 102132;
+  if (!db->GetParticle(ionCode)) {
+    db->AddParticle("Lambda_1405_0", "Lambda_1405_0", 1.405, kFALSE, 0.05, 0, "Resonance", ionCode);
+  }
+  if (!db->GetParticle(-ionCode)) {
+    db->AddParticle("AntiLambda_1405_0", "AntiLambda_1405_0", 1.405, kFALSE, 0.05, 0, "Resonance", -ionCode);
+  }
+
   // Lambda(1520)0
   ionCode = 102134;
   if (!db->GetParticle(ionCode)) {

DataFormats/simulation/include/SimulationDataFormat/O2DatabasePDG.h

@@ -246,7 +246,7 @@ class AODProducerWorkflowDPL : public Task
   std::mt19937 mGenerator{}; ///< random generator for trackQA sampling
   o2::base::Propagator::MatCorrType mMatCorr{o2::base::Propagator::MatCorrType::USEMatCorrLUT};
   o2::dataformats::MeanVertexObject mVtx;
-  float mMinPropR{o2::constants::geom::XTPCInnerRef + 0.1f};
+  float mMaxPropXiu{5.0f}; // max X_IU for which track is to be propagated if mPropTracks is true. (other option: o2::constants::geom::XTPCInnerRef + 0.1f)
 
   std::unordered_set<GIndex> mGIDUsedBySVtx;
   std::unordered_set<GIndex> mGIDUsedByStr;

Detectors/AOD/include/AODProducerWorkflow/AODProducerWorkflowSpec.h

@@ -540,7 +540,7 @@ void AODProducerWorkflowDPL::fillTrackTablesPerCollision(int collisionID,
           }
           const auto& trOrig = data.getTrackParam(trackIndex);
           bool isProp = false;
-          if (mPropTracks && trOrig.getX() < mMinPropR &&
+          if (mPropTracks && trOrig.getX() < mMaxPropXiu &&
               mGIDUsedBySVtx.find(trackIndex) == mGIDUsedBySVtx.end() &&
               mGIDUsedByStr.find(trackIndex) == mGIDUsedByStr.end()) { // Do not propagate track assoc. to V0s and str. tracking
             auto trackPar(trOrig);
@@ -1688,6 +1688,7 @@ void AODProducerWorkflowDPL::init(InitContext& ic)
   mEMCselectLeading = ic.options().get<bool>("emc-select-leading");
   mThinTracks = ic.options().get<bool>("thin-tracks");
   mPropTracks = ic.options().get<bool>("propagate-tracks");
+  mMaxPropXiu = ic.options().get<float>("propagate-tracks-max-xiu");
   mPropMuons = ic.options().get<bool>("propagate-muons");
   if (auto s = ic.options().get<std::string>("with-streamers"); !s.empty()) {
     mStreamerFlags.set(s);
@@ -3299,6 +3300,7 @@ DataProcessorSpec getAODProducerWorkflowSpec(GID::mask_t src, bool enableSV, boo
       ConfigParamSpec{"ctpreadout-create", VariantType::Int, 0, {"Create CTP digits from detector readout and CTP inputs. !=1 -- off, 1 -- on"}},
       ConfigParamSpec{"emc-select-leading", VariantType::Bool, false, {"Flag to select if only the leading contributing particle for an EMCal cell should be stored"}},
       ConfigParamSpec{"propagate-tracks", VariantType::Bool, false, {"Propagate tracks (not used for secondary vertices) to IP"}},
+      ConfigParamSpec{"propagate-tracks-max-xiu", VariantType::Float, 5.0f, {"Propagate tracks to IP if X_IU smaller than this value (and if propagate tracks enabled)"}},
       ConfigParamSpec{"hepmc-update", VariantType::String, "always", {"When to update HepMC Aux tables: always - force update, never - never update, all - if all keys are present, any - when any key is present (not valid yet)"}},
       ConfigParamSpec{"propagate-muons", VariantType::Bool, false, {"Propagate muons to IP"}},
       ConfigParamSpec{"thin-tracks", VariantType::Bool, false, {"Produce thinned track tables"}},