Merge branch 'AliceO2Group:dev' into new-detector4

Author: pkurash

CCDB/src/CCDBDownloader.cxx

@@ -485,7 +485,7 @@ void CCDBDownloader::transferFinished(CURL* easy_handle, CURLcode curlCode)
   bool contentRetrieved = false;
 
   if (curlCode != 0) {
-    LOG(error) << "CCDBDownloader: " << curl_easy_strerror(curlCode) << "\n";
+    LOG(error) << "CCDBDownloader CURL transfer error - " << curl_easy_strerror(curlCode) << "\n";
   }
 
   switch (performData->type) {
@@ -520,15 +520,14 @@ void CCDBDownloader::transferFinished(CURL* easy_handle, CURLcode curlCode)
         } else if (300 <= httpCode && httpCode < 400 && performData->locInd < locations.size()) {
           followRedirect(performData, easy_handle, locations, rescheduled, contentRetrieved);
         } else if (200 <= httpCode && httpCode < 300) {
-          contentRetrieved = true; // Can be overruled by following timeout check
+          contentRetrieved = true; // Can be overruled by following error check
         }
       } else {
         LOG(error) << loggingMessage;
       }
 
-      // Check for timeout
-      if (curlCode == CURLE_OPERATION_TIMEDOUT) {
-        LOG(error) << "Connection timed out.\n";
+      // Check for errors
+      if (curlCode != 0) {
         contentRetrieved = false;
       }
 

DataFormats/Reconstruction/src/TrackParametrization.cxx

@@ -956,8 +956,10 @@ GPUd() typename TrackParametrization<value_T>::value_t TrackParametrization<valu
 
 namespace o2::track
 {
+#if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
 template class TrackParametrization<float>;
-#ifndef GPUCA_GPUCODE_DEVICE
+#endif
+#ifndef GPUCA_GPUCODE
 template class TrackParametrization<double>;
 #endif
 } // namespace o2::track

DataFormats/Reconstruction/src/TrackParametrizationWithError.cxx

@@ -1245,8 +1245,10 @@ GPUd() void TrackParametrizationWithError<value_T>::printHexadecimal()
 
 namespace o2::track
 {
+#if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
 template class TrackParametrizationWithError<float>;
-#ifndef GPUCA_GPUCODE_DEVICE
+#endif
+#ifndef GPUCA_GPUCODE
 template class TrackParametrizationWithError<double>;
 #endif
 } // namespace o2::track

Detectors/Base/src/Propagator.cxx

@@ -786,8 +786,10 @@ GPUd() void PropagatorImpl<value_T>::getFieldXYZ(const math_utils::Point3D<doubl
 
 namespace o2::base
 {
+#if !defined(GPUCA_GPUCODE) || defined(GPUCA_GPUCODE_DEVICE) // FIXME: DR: WORKAROUND to avoid CUDA bug creating host symbols for device code.
 template class PropagatorImpl<float>;
-#ifndef GPUCA_GPUCODE_DEVICE
+#endif
+#ifndef GPUCA_GPUCODE
 template class PropagatorImpl<double>;
 #endif
 #ifndef __HIPCC__ // TODO: Fixme: must prevent HIP from compiling this, should file bug report

Detectors/Calibration/README.md

@@ -42,6 +42,13 @@ In order to prepare only one CCDB object at the end of the run you can use `setU
 
 See e.g. LHCClockCalibrator.h/cxx in AliceO2/Detectors/TOF/calibration/include/TOFCalibration/LHCClockCalibrator.h and  AliceO2/Detectors/TOF/calibration/srcLHCClockCalibrator.cxx
 
+Sometimes it might be useful to define the 1st slot of the run shorter than the nominal slot length, e.g. to not rely to long on the previous run or default calibration. In this case one can impose to the
+calibration class an offset using method `setStartOffsetFrac(float offset)`, where `offset` is a fractional of the nominal slot length to be subtracted from the nominal boundaries of all slots (except the
+very 1st one, whose startTF is set to 0). The fractional offset should be in `[0:0.95)` range, any value outside this range will be overridden to the nearest boundary.
+This feature is supported only for the finite slot-length calibrations. E.g. if the nominal slot length is 10 minutes `(==~210000 TFs)`, setting `setStartOffsetFrac(float 0.7)` will lead to 1st slot
+finalized after the first 3 minutes, while the rest of the slots will be defined with nominal 10 minutes coverage. If statistics of this 1st short slot is insufficient, it will be merged as usual
+with the next slot (note this if this happens, in the example above the 1st calibration will be available in 13 minutes...).
+
 ## TimeSlot<Container>
 
 The TimeSlot is a templated class which takes as input type the Container that will hold the calibration data needed to produce the calibration objects (histograms, vectors, array...). Each calibration device could implement its own Container, according to its needs.

Detectors/Calibration/include/DetectorsCalibration/TimeSlotCalibration.h

@@ -87,12 +87,35 @@ class TimeSlotCalibration
       setSlotLength(ntf);
       mSlotLengthInOrbits = 0;
     }
+    setStartOffsetFrac(mStartOffsetFrac); // set once more to account for eventual dependencies
+    mStartOffsetTFs = TFType(mSlotLength * mStartOffsetFrac);
+  }
+
+  void setStartOffsetFrac(float f)
+  {
+    if (mUpdateAtTheEndOfRunOnly || mFinalizeWhenReady || mSlotLength == INFINITE_TF) { // offset makes no sense for run-wide objects
+      if (f) {
+        LOGP(info, "Start offset is not supported in the INFINITE_TF slot length or UpdateAtTheEndOfRunOnly or FinalizeWhenReady modes");
+      }
+      return;
+    }
+    if (f < 0.) {
+      mStartOffsetFrac = 0.;
+    } else if (f > 0.95) {
+      mStartOffsetFrac = 0.95;
+    } else {
+      mStartOffsetFrac = f;
+    }
+    if (mStartOffsetFrac || f != mStartOffsetFrac) {
+      LOGP(info, "Imposing offset of {:4.2} x nominal slot length", mStartOffsetFrac);
+    }
   }
 
   void setFinalizeWhenReady()
   {
     mFinalizeWhenReady = true;
     setSlotLength(INFINITE_TF);
+    mStartOffsetFrac = 0;
   }
 
   void setUpdateAtTheEndOfRunOnly() { mUpdateAtTheEndOfRunOnly = kTRUE; }
@@ -219,7 +242,6 @@ class TimeSlotCalibration
   }
 
   TFType tf2SlotMin(TFType tf) const;
-
   std::deque<Slot> mSlots;
 
   o2::dataformats::TFIDInfo mCurrentTFInfo{};
@@ -229,6 +251,8 @@ class TimeSlotCalibration
   TFType mFirstTF = 0;
   TFType mMaxSeenTF = 0;                        // largest TF processed
   TFType mSlotLength = 1;                       // slot length in TFs
+  TFType mStartOffsetTFs = 0;                   // shift start of all TFs backwards by this amount (to make 1st slot effectively shorter: run_1st_tf to run_1st_tf - offset + mSlotLength), derived from mStartOffsetFrac
+  float mStartOffsetFrac = 0.;                  // shift start of all TFs backwards mSlotLength*mStartOffsetFrac TFs.
   TFType mCheckIntervalInfiniteSlot = 1;        // will be used if the TF length is INFINITE_TF_int64 to decide
                                                 // when to check if to call the finalize; otherwise it is called
                                                 // at every new TF; note that this is an approximation,
@@ -381,16 +405,20 @@ void TimeSlotCalibration<Container>::finalizeOldestSlot()
 template <typename Container>
 inline TFType TimeSlotCalibration<Container>::tf2SlotMin(TFType tf) const
 {
-
   // returns the min TF of the slot to which "tf" belongs
-
   if (tf < mFirstTF) {
     throw std::runtime_error("invalid TF");
   }
   if (mUpdateAtTheEndOfRunOnly) {
     return mFirstTF;
   }
-  uint64_t tft = int64_t(((tf - mFirstTF) / mSlotLength) * mSlotLength) + mFirstTF;
+  int64_t tft = 0;
+  tft = int64_t(((tf - mFirstTF + mStartOffsetTFs) / mSlotLength) * mSlotLength) + mFirstTF;
+  if (tft > mStartOffsetTFs) {
+    tft -= mStartOffsetTFs;
+  } else {
+    tft = 0;
+  }
   return tft < o2::calibration::INFINITE_TF ? TFType(tft) : INFINITE_TF;
 }
 
@@ -415,7 +443,7 @@ TimeSlot<Container>& TimeSlotCalibration<Container>::getSlotForTF(TFType tf)
     auto tfmn = tf2SlotMin(mSlots.front().getTFStart() - 1); // min TF of the slot corresponding to a TF smaller than the first seen
     auto tftgt = tf2SlotMin(tf);                             // min TF of the slot to which the TF "tf" would belong
     while (tfmn >= tftgt) {
-      uint64_t tft = uint64_t(tfmn) + mSlotLength - 1;
+      uint64_t tft = mSlots.front().getTFStart() - 1;
       TFType tfmx = tft < o2::calibration::INFINITE_TF ? TFType(tft) : o2::calibration::INFINITE_TF;
       LOG(info) << "Adding new slot for " << tfmn << " <= TF <= " << tfmx;
       auto& sl = emplaceNewSlot(true, tfmn, tfmx);
@@ -438,12 +466,15 @@ TimeSlot<Container>& TimeSlotCalibration<Container>::getSlotForTF(TFType tf)
   auto tfmn = mSlots.empty() ? tf2SlotMin(tf) : tf2SlotMin(mSlots.back().getTFEnd() + 1);
   do {
     uint64_t tft = uint64_t(tfmn) + mSlotLength - 1;
+    if (mSlots.empty() && mStartOffsetTFs && tf < mStartOffsetTFs) { // if this was lowest possible TF, its length might be smaller than mSlotLength
+      tft -= mStartOffsetTFs;
+    }
     TFType tfmx = tft < o2::calibration::INFINITE_TF ? TFType(tft) : o2::calibration::INFINITE_TF;
     LOG(info) << "Adding new slot for " << tfmn << " <= TF <= " << tfmx;
     auto& sl = emplaceNewSlot(false, tfmn, tfmx);
     sl.setRunStartOrbit(getRunStartOrbit());
     sl.setStaticStartTimeMS(sl.getStartTimeMS());
-    tfmn = tf2SlotMin(mSlots.back().getTFEnd() + 1);
+    tfmn = tft < o2::calibration::INFINITE_TF ? mSlots.back().getTFEnd() + 1 : tft;
   } while (tf > mSlots.back().getTFEnd());
 
   return mSlots.back();

Detectors/FIT/macros/CMakeLists.txt

@@ -40,4 +40,5 @@ o2_add_test_root_macro(readFITDCSdata.C
                                              O2::CCDB
                        LABELS fit)
 
-o2_data_file(COPY readFITDCSdata.C DESTINATION Detectors/FIT/macros/readFITDCSdata.C)
+o2_data_file(COPY readFITDCSdata.C DESTINATION Detectors/FIT/macros/readFITDCSdata.C)
+o2_data_file(COPY readFITDeadChannelMap.C DESTINATION Detectors/FIT/macros/readFITDeadChannelMap.C)

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TimeFrameGPU.h

@@ -174,9 +174,9 @@ class GpuTimeFrameChunk
 template <int nLayers = 7>
 class TimeFrameGPU : public TimeFrame
 {
- public:
   friend class GpuTimeFrameChunk<nLayers>;
 
+ public:
   TimeFrameGPU();
   ~TimeFrameGPU();
 
@@ -185,7 +185,7 @@ class TimeFrameGPU : public TimeFrame
   void unregisterHostMemory(const int);
   void initialise(const int, const TrackingParameters&, const int, IndexTableUtils* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
   void initialiseHybrid(const int, const TrackingParameters&, const int, IndexTableUtils* utils = nullptr, const TimeFrameGPUParameters* pars = nullptr);
-  void initDevice(const int, IndexTableUtils*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
+  void initDevice(IndexTableUtils*, const TrackingParameters& trkParam, const TimeFrameGPUParameters&, const int, const int);
   void initDeviceSAFitting();
   void loadTrackingFrameInfoDevice(const int);
   void loadUnsortedClustersDevice();
@@ -227,7 +227,8 @@ class TimeFrameGPU : public TimeFrame
   TrackITSExt* getDeviceTrackITSExt() { return mTrackITSExtDevice; }
   gpuPair<int, int>* getDeviceNeighbours(const int layer) { return mNeighboursDevice[layer]; }
   TrackingFrameInfo* getDeviceTrackingFrameInfo(const int);
-  TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() { return mTrackingFrameInfoDeviceArray; }
+  // TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() { return mTrackingFrameInfoDeviceArray; }
+  const TrackingFrameInfo** getDeviceArrayTrackingFrameInfo() const { return mTrackingFrameInfoDeviceArray; }
   Cluster** getDeviceArrayClusters() const { return mClustersDeviceArray; }
   Cluster** getDeviceArrayUnsortedClusters() const { return mUnsortedClustersDeviceArray; }
   Tracklet** getDeviceArrayTracklets() const { return mTrackletsDeviceArray; }
@@ -275,7 +276,7 @@ class TimeFrameGPU : public TimeFrame
   TrackITSExt* mTrackITSExtDevice;
   std::array<gpuPair<int, int>*, nLayers - 2> mNeighboursDevice;
   std::array<TrackingFrameInfo*, nLayers> mTrackingFrameInfoDevice;
-  TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
+  const TrackingFrameInfo** mTrackingFrameInfoDeviceArray;
 
   // State
   std::vector<Stream> mGpuStreams;

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/TrackingKernels.h

@@ -16,9 +16,7 @@
 #include "DetectorsBase/Propagator.h"
 #include "GPUCommonDef.h"
 
-namespace o2
-{
-namespace its
+namespace o2::its
 {
 class CellSeed;
 namespace gpu
@@ -40,9 +38,9 @@ GPUd() bool fitTrack(TrackITSExt& track,
 template <int nLayers = 7>
 GPUg() void fitTrackSeedsKernel(
   CellSeed* trackSeeds,
-  TrackingFrameInfo** foundTrackingFrameInfo,
+  const TrackingFrameInfo** foundTrackingFrameInfo,
   o2::its::TrackITSExt* tracks,
-  const size_t nSeeds,
+  const unsigned int nSeeds,
   const float Bz,
   const int startLevel,
   float maxChi2ClusterAttachment,
@@ -53,15 +51,14 @@ GPUg() void fitTrackSeedsKernel(
 } // namespace gpu
 
 void trackSeedHandler(CellSeed* trackSeeds,
-                      TrackingFrameInfo** foundTrackingFrameInfo,
+                      const TrackingFrameInfo** foundTrackingFrameInfo,
                       o2::its::TrackITSExt* tracks,
-                      const size_t nSeeds,
+                      const unsigned int nSeeds,
                       const float Bz,
                       const int startLevel,
                       float maxChi2ClusterAttachment,
                       float maxChi2NDF,
                       const o2::base::Propagator* propagator,
                       const o2::base::PropagatorF::MatCorrType matCorrType);
-} // namespace its
-} // namespace o2
+} // namespace o2::its
 #endif // ITSTRACKINGGPU_TRACKINGKERNELS_H_

Detectors/ITSMFT/ITS/tracking/GPU/ITStrackingGPU/VertexingKernels.h

@@ -0,0 +1,59 @@
+// 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 ITSTRACKINGGPU_VERTEXINGKERNELS_H_
+#define ITSTRACKINGGPU_VERTEXINGKERNELS_H_
+#include "ITStracking/MathUtils.h"
+#include "ITStracking/Configuration.h"
+#include "ITStracking/ClusterLines.h"
+#include "ITStracking/Tracklet.h"
+
+#include "ITStrackingGPU/Utils.h"
+#include "ITStrackingGPU/ClusterLinesGPU.h"
+#include "ITStrackingGPU/VertexerTraitsGPU.h"
+#include "ITStrackingGPU/TracerGPU.h"
+
+#include "GPUCommonArray.h"
+
+namespace o2::its::gpu
+{
+#ifdef GPUCA_GPUCODE // GPUg() global kernels must only when compiled by GPU compiler
+template <TrackletMode Mode>
+GPUg() void trackleterKernelMultipleRof(
+  const Cluster* clustersNextLayer,    // 0 2
+  const Cluster* clustersCurrentLayer, // 1 1
+  const int* sizeNextLClusters,
+  const int* sizeCurrentLClusters,
+  const int* nextIndexTables,
+  Tracklet* Tracklets,
+  int* foundTracklets,
+  const IndexTableUtils* utils,
+  const unsigned int startRofId,
+  const unsigned int rofSize,
+  const float phiCut,
+  const size_t maxTrackletsPerCluster);
+#endif
+template <TrackletMode Mode>
+void trackletFinderHandler(const Cluster* clustersNextLayer,    // 0 2
+                           const Cluster* clustersCurrentLayer, // 1 1
+                           const int* sizeNextLClusters,
+                           const int* sizeCurrentLClusters,
+                           const int* nextIndexTables,
+                           Tracklet* Tracklets,
+                           int* foundTracklets,
+                           const IndexTableUtils* utils,
+                           const unsigned int startRofId,
+                           const unsigned int rofSize,
+                           const float phiCut,
+                           const size_t maxTrackletsPerCluster = 1e2);
+} // namespace o2::its::gpu
+#endif