Merge 610fb48 into sapling-pr-archive-ktf

Author: ktf

CCDB/include/CCDB/BasicCCDBManager.h

@@ -108,16 +108,20 @@ class CCDBManagerInstance
 
   /// retrieve an object of type T from CCDB as stored under path, timestamp and metaData
   template <typename T>
-  T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD())
+  T* getSpecific(std::string const& path, long timestamp = -1, MD metaData = MD(), std::map<std::string, std::string>* headers = nullptr)
   {
     // TODO: add some error info/handling when failing
     mMetaData = metaData;
-    return getForTimeStamp<T>(path, timestamp);
+    auto obj = getForTimeStamp<T>(path, timestamp);
+    if (headers) {
+      *headers = mHeaders;
+    }
+    return obj;
   }
 
   /// retrieve an object of type T from CCDB as stored under path and using the timestamp in the middle of the run + metadata. The run number is provided separately to conform to typical analysis use (in which case metadata does not include runNumber)
   template <typename T>
-  T* getSpecificForRun(std::string const& path, int runNumber, MD metaData = MD());
+  T* getSpecificForRun(std::string const& path, int runNumber, MD const& metaData = MD());
 
   /// detect online processing modes (i.e. CCDB objects may be updated in the lifetime of the manager)
   bool isOnline() const { return mDeplMode == o2::framework::DeploymentMode::OnlineAUX || mDeplMode == o2::framework::DeploymentMode::OnlineDDS || mDeplMode == o2::framework::DeploymentMode::OnlineECS; }
@@ -129,6 +133,9 @@ class CCDBManagerInstance
     return getForTimeStamp<T>(path, mTimestamp);
   }
 
+  // gain access to underlaying CCDB layer (to allow for more complex queries without need to reinit another API)
+  CcdbApi& getCCDBAccessor() { return mCCDBAccessor; }
+
   bool isHostReachable() const { return mCCDBAccessor.isHostReachable(); }
 
   /// clear all entries in the cache
@@ -230,11 +237,12 @@ class CCDBManagerInstance
 template <typename T>
 T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
 {
+  mHeaders.clear(); // we clear at the beginning; to allow to retrieve the header information in a subsequent call
   T* ptr = nullptr;
   mQueries++;
   auto start = std::chrono::system_clock::now();
   if (!isCachingEnabled()) {
-    ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, nullptr, "",
+    ptr = mCCDBAccessor.retrieveFromTFileAny<T>(path, mMetaData, timestamp, &mHeaders, "",
                                                 mCreatedNotAfter ? std::to_string(mCreatedNotAfter) : "",
                                                 mCreatedNotBefore ? std::to_string(mCreatedNotBefore) : "");
     if (!ptr) {
@@ -305,7 +313,6 @@ T* CCDBManagerInstance::getForTimeStamp(std::string const& path, long timestamp)
     } else {
       cached.cacheValidUntil = -1;
     }
-    mHeaders.clear();
     mMetaData.clear();
     if (!ptr) {
       if (mFatalWhenNull) {
@@ -328,7 +335,7 @@ T* CCDBManagerInstance::getForRun(std::string const& path, int runNumber, bool s
 }
 
 template <typename T>
-T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD metaData)
+T* CCDBManagerInstance::getSpecificForRun(std::string const& path, int runNumber, MD const& metaData)
 {
   auto [start, stop] = getRunDuration(runNumber, mFatalWhenNull);
   if (start < 0 || stop < 0) {

DataFormats/Parameters/include/DataFormatsParameters/AggregatedRunInfo.h

@@ -32,17 +32,35 @@ struct AggregatedRunInfo {
   int runNumber = 0;       // run number
   int64_t sor = 0;         // best known timestamp for the start of run
   int64_t eor = 0;         // best known timestamp for end of run
-  int64_t orbitsPerTF = 0; // number of orbits per TF
+  int64_t orbitsPerTF = 0; // number of orbits per TF (takes precedence over that in GRPECS)
   int64_t orbitReset = 0;  // timestamp of orbit reset before run
   int64_t orbitSOR = 0;    // orbit when run starts after orbit reset
   int64_t orbitEOR = 0;    // orbit when run ends after orbit reset
 
   // we may have pointers to actual data source objects GRPECS, ...
   const o2::parameters::GRPECSObject* grpECS = nullptr; // pointer to GRPECSobject (fetched during struct building)
 
-  // fills and returns AggregatedRunInfo for a given run number.
-  static AggregatedRunInfo buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber);
   static AggregatedRunInfo buildAggregatedRunInfo(int runnumber, long sorMS, long eorMS, long orbitResetMUS, const o2::parameters::GRPECSObject* grpecs, const std::vector<Long64_t>* ctfFirstRunOrbitVec);
+
+  // fills and returns AggregatedRunInfo for a given data run number.
+  static AggregatedRunInfo buildAggregatedRunInfo_DATA(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber);
+
+  // Returns the meta-data (MCProdInfo) associated to production lpm_prod_tag (performed by username)
+  static std::map<std::string, std::string> getMCProdInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber,
+                                                          std::string const& lpm_prod_tag, std::string const& username = "aliprod");
+
+  // function that adjusts with values from MC
+  void adjust_from_MC(o2::ccdb::CCDBManagerInstance& ccdb, int run_number, std::string const& lpm_prod_tag, std::string const& username = "aliprod");
+
+  // Fills and returns AggregatedRunInfo for a given run number.
+  // If a non-empty lpm_prod_tag is given, it will potentially override values with specifics from a
+  // MC production identified by that tag and username.
+  static AggregatedRunInfo buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb,
+                                                  int runnumber,
+                                                  std::string const& lpm_prod_tag = "",
+                                                  std::string const& username = "aliprod");
+
+  ClassDefNV(AggregatedRunInfo, 1);
 };
 
 } // namespace o2::parameters

DataFormats/Parameters/src/AggregatedRunInfo.cxx

@@ -21,7 +21,7 @@
 
 using namespace o2::parameters;
 
-o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber)
+o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo_DATA(o2::ccdb::CCDBManagerInstance& ccdb, int runnumber)
 {
   // TODO: could think about caching results per runnumber to
   // avoid going to CCDB multiple times ---> but should be done inside the CCDBManagerInstance
@@ -83,3 +83,67 @@ o2::parameters::AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(int
   }
   return AggregatedRunInfo{runnumber, sorMS, eorMS, nOrbitsPerTF, orbitResetMUS, orbitSOR, orbitEOR, grpecs};
 }
+
+namespace
+{
+
+// get path where to find MC production info
+std::string getFullPath_MC(std::string const& username, std::string const& lpm_prod_tag)
+{
+  // construct the path where to lookup
+  std::string path = "/Users/" + std::string(1, username[0]) + "/" + username;
+  std::string fullpath = path + "/" + "MCProdInfo/" + lpm_prod_tag;
+  return fullpath;
+}
+
+} // namespace
+
+std::map<std::string, std::string> AggregatedRunInfo::getMCProdInfo(o2::ccdb::CCDBManagerInstance& ccdb,
+                                                                    int run_number,
+                                                                    std::string const& lpm_prod_tag,
+                                                                    std::string const& username)
+{
+  std::map<std::string, std::string> metaDataFilter;
+  metaDataFilter["LPMProductionTag"] = lpm_prod_tag;
+
+  // fetch the meta information for MC productions
+  auto header_data = ccdb.getCCDBAccessor().retrieveHeaders(getFullPath_MC(username, lpm_prod_tag), metaDataFilter, run_number);
+  return header_data;
+}
+
+void AggregatedRunInfo::adjust_from_MC(o2::ccdb::CCDBManagerInstance& ccdb,
+                                       int run_number,
+                                       std::string const& lpm_prod_tag,
+                                       std::string const& username)
+{
+  auto header_data = AggregatedRunInfo::getMCProdInfo(ccdb, run_number, lpm_prod_tag, username);
+
+  // adjust timeframe length if we find entry for MC production
+  auto iter = header_data.find("OrbitsPerTF");
+  if (iter != header_data.end()) {
+    auto mc_orbitsPerTF = std::stoi(iter->second);
+    if (mc_orbitsPerTF != orbitsPerTF) {
+      LOG(info) << "Adjusting OrbitsPerTF from " << orbitsPerTF << " to " << mc_orbitsPerTF << " based on differing MC info";
+      orbitsPerTF = mc_orbitsPerTF;
+    }
+  } else {
+    LOG(warn) << "No OrbitsPerTF information found for MC production " << lpm_prod_tag << " and run number " << run_number;
+  }
+}
+
+AggregatedRunInfo AggregatedRunInfo::buildAggregatedRunInfo(o2::ccdb::CCDBManagerInstance& ccdb, int run_number, std::string const& lpm_prod_tag, std::string const& username)
+{
+  // (a) lookup the AggregatedRunInfo for the data run
+  // (b) modify/overwrite the info object with MC specific settings if lpm_prod_tag is given
+
+  auto original_info = buildAggregatedRunInfo_DATA(ccdb, run_number);
+
+  if (lpm_prod_tag.size() == 0) {
+    return original_info;
+  }
+
+  // in this case we adjust the info from MC
+  original_info.adjust_from_MC(ccdb, run_number, lpm_prod_tag, username);
+
+  return original_info;
+}

DataFormats/Parameters/src/GRPLHCIFData.cxx

@@ -28,6 +28,8 @@ using namespace o2::constants::lhc;
 const std::unordered_map<unsigned int, unsigned int> GRPLHCIFData::mZtoA =
   {
     {1, 1},
+    {8, 16},
+    {10, 20},
     {82, 208}};
 
 //_______________________________________________

DataFormats/simulation/include/SimulationDataFormat/TrackReference.h

@@ -171,7 +171,7 @@ class TrackReference
   float mTrackLength = 0; ///< track length from its origin in cm
   float mTof = 0;         ///< time of flight in cm
   Int_t mUserId = 0;      ///< optional Id defined by user
-  Int_t mDetectorId = 0;  ///< Detector Id
+  Int_t mDetectorId = -1; ///< sensitive Detector Id (-1 if unknown or in passive material)
   SimTrackStatus mStatus; ///< encoding the track status
 
   friend std::ostream& operator<<(std::ostream&, const TrackReference&);

Detectors/AOD/src/AODProducerWorkflowSpec.cxx

@@ -2717,7 +2717,7 @@ AODProducerWorkflowDPL::TrackQA AODProducerWorkflowDPL::processBarrelTrackQA(int
     if (auto itsContGID = data.getITSContributorGID(trackIndex); itsContGID.isIndexSet() && itsContGID.getSource() != GIndex::ITSAB) {
       const auto& itsOrig = data.getITSTrack(itsContGID);
       o2::track::TrackPar gloCopy = trackPar;
-      o2::track::TrackPar itsCopy = itsOrig;
+      o2::track::TrackPar itsCopy = itsOrig.getParamOut();
       o2::track::TrackPar tpcCopy = tpcOrig;
       if (prop->propagateToX(gloCopy, o2::aod::track::trackQARefRadius, prop->getNominalBz(), o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, mMatCorr) &&
           prop->propagateToAlphaX(tpcCopy, gloCopy.getAlpha(), o2::aod::track::trackQARefRadius, false, o2::base::Propagator::MAX_SIN_PHI, o2::base::Propagator::MAX_STEP, 1, mMatCorr) &&

Detectors/ITSMFT/ITS/tracking/CMakeLists.txt

@@ -36,7 +36,9 @@ o2_add_library(ITStracking
                        O2::ITSReconstruction
                        O2::ITSMFTReconstruction
                        O2::DataFormatsITS
-               PRIVATE_LINK_LIBRARIES TBB::tbb)
+               PRIVATE_LINK_LIBRARIES
+                       O2::Steer
+                       TBB::tbb)
 
 o2_add_library(ITSTrackingInterface
                TARGETVARNAME targetName

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackerTraitsGPU.cxx

@@ -246,7 +246,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                                         this->mTrkParams[0].MaxChi2ClusterAttachment,
                                         this->mTrkParams[0].MaxChi2NDF,
                                         mTimeFrameGPU->getDevicePropagator(),
-                                        this->mCorrType,
+                                        this->mTrkParams[0].CorrType,
                                         conf.nBlocks,
                                         conf.nThreads);
     }
@@ -268,7 +268,7 @@ void TrackerTraitsGPU<nLayers>::findRoads(const int iteration)
                      this->mTrkParams[0].MaxChi2ClusterAttachment,     // float maxChi2ClusterAttachment
                      this->mTrkParams[0].MaxChi2NDF,                   // float maxChi2NDF
                      mTimeFrameGPU->getDevicePropagator(),             // const o2::base::Propagator* propagator
-                     this->mCorrType,                                  // o2::base::PropagatorImpl<float>::MatCorrType
+                     this->mTrkParams[0].CorrType,                     // o2::base::PropagatorImpl<float>::MatCorrType
                      conf.nBlocks,
                      conf.nThreads);
 

Detectors/ITSMFT/ITS/tracking/GPU/cuda/TrackingKernels.cu

@@ -58,30 +58,43 @@ namespace gpu
 {
 
 template <typename T>
-class TypedAllocator : public thrust::device_allocator<T>
-{
- public:
+struct TypedAllocator {
   using value_type = T;
-  using pointer = T*;
+  using pointer = thrust::device_ptr<T>;
+  using const_pointer = thrust::device_ptr<const T>;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  TypedAllocator() noexcept : mInternalAllocator(nullptr) {}
+  explicit TypedAllocator(ExternalAllocator* a) noexcept : mInternalAllocator(a) {}
 
   template <typename U>
-  struct rebind {
-    using other = TypedAllocator<U>;
-  };
+  TypedAllocator(const TypedAllocator<U>& o) noexcept : mInternalAllocator(o.mInternalAllocator)
+  {
+  }
 
-  explicit TypedAllocator(ExternalAllocator* allocPtr)
-    : mInternalAllocator(allocPtr) {}
+  pointer allocate(size_type n)
+  {
+    void* raw = mInternalAllocator->allocate(n * sizeof(T));
+    return thrust::device_pointer_cast(static_cast<T*>(raw));
+  }
 
-  T* allocate(size_t n)
+  void deallocate(pointer p, size_type n) noexcept
   {
-    return reinterpret_cast<T*>(mInternalAllocator->allocate(n * sizeof(T)));
+    if (!p) {
+      return;
+    }
+    void* raw = thrust::raw_pointer_cast(p);
+    mInternalAllocator->deallocate(static_cast<char*>(raw), n * sizeof(T));
   }
 
-  void deallocate(T* p, size_t n)
+  bool operator==(TypedAllocator const& o) const noexcept
+  {
+    return mInternalAllocator == o.mInternalAllocator;
+  }
+  bool operator!=(TypedAllocator const& o) const noexcept
   {
-    char* raw_ptr = reinterpret_cast<char*>(p);
-    size_t bytes = n * sizeof(T);
-    mInternalAllocator->deallocate(raw_ptr, bytes); // redundant as internal dealloc is no-op.
+    return !(*this == o);
   }
 
  private:

Detectors/ITSMFT/ITS/tracking/include/ITStracking/Configuration.h

@@ -26,36 +26,8 @@
 #include "DetectorsBase/Propagator.h"
 #include "ITStracking/Constants.h"
 
-namespace o2
+namespace o2::its
 {
-namespace its
-{
-
-enum class TrackingMode {
-  Sync,
-  Async,
-  Cosmics,
-  Unset, // Special value to leave a default in case we want to override via Configurable Params
-};
-
-std::string asString(TrackingMode mode);
-std::ostream& operator<<(std::ostream& os, TrackingMode v);
-
-template <typename Param>
-class Configuration : public Param
-{
- public:
-  static Configuration<Param>& getInstance()
-  {
-    static Configuration<Param> instance;
-    return instance;
-  }
-  Configuration(const Configuration<Param>&) = delete;
-  const Configuration<Param>& operator=(const Configuration<Param>&) = delete;
-
- private:
-  Configuration() = default;
-};
 
 struct TrackingParameters {
   int CellMinimumLevel() const noexcept { return MinTrackLength - constants::ClustersPerCell + 1; }
@@ -140,6 +112,9 @@ struct VertexingParameters {
   int zSpan = -1;
   bool SaveTimeBenchmarks = false;
 
+  bool useTruthSeeding = false; // overwrite found vertices with MC events
+  bool outputContLabels = false;
+
   int nThreads = 1;
   bool PrintMemory = false; // print allocator usage in epilog report
   size_t MaxMemory = std::numeric_limits<size_t>::max();
@@ -166,7 +141,24 @@ struct TimeFrameGPUParameters {
   int maxGPUMemoryGB = -1;
 };
 
-} // namespace its
-} // namespace o2
+namespace TrackingMode
+{
+enum Type : int8_t {
+  Unset = -1, // Special value to leave a default in case we want to override via Configurable Params
+  Sync = 0,
+  Async = 1,
+  Cosmics = 2,
+  Off = 3,
+};
+
+Type fromString(std::string_view str);
+std::string toString(Type mode);
+
+std::vector<TrackingParameters> getTrackingParameters(Type mode);
+std::vector<VertexingParameters> getVertexingParameters(Type mode);
+
+}; // namespace TrackingMode
+
+} // namespace o2::its
 
 #endif /* TRACKINGITSU_INCLUDE_CONFIGURATION_H_ */