Merge branch 'dev' into pr14910

Author: ktf

DataFormats/Detectors/TPC/include/DataFormatsTPC/Defs.h

@@ -97,23 +97,6 @@ enum class StatisticsType {
   MeanStdDev   ///< Use mean and standard deviation
 };
 
-enum class PadFlags : unsigned short {
-  flagGoodPad = 1 << 0,      ///< flag for a good pad binary 0001
-  flagDeadPad = 1 << 1,      ///< flag for a dead pad binary 0010
-  flagUnknownPad = 1 << 2,   ///< flag for unknown status binary 0100
-  flagSaturatedPad = 1 << 3, ///< flag for saturated status binary 0100
-  flagHighPad = 1 << 4,      ///< flag for pad with extremly high IDC value
-  flagLowPad = 1 << 5,       ///< flag for pad with extremly low IDC value
-  flagSkip = 1 << 6,         ///< flag for defining a pad which is just ignored during the calculation of I1 and IDCDelta
-  flagFEC = 1 << 7,          ///< flag for a whole masked FEC
-  flagNeighbour = 1 << 8,    ///< flag if n neighbouring pads are outlier
-  flagAllNoneGood = flagDeadPad | flagUnknownPad | flagSaturatedPad | flagHighPad | flagLowPad | flagSkip | flagFEC | flagNeighbour,
-};
-
-inline PadFlags operator&(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) & static_cast<int>(b)); }
-inline PadFlags operator~(PadFlags a) { return static_cast<PadFlags>(~static_cast<int>(a)); }
-inline PadFlags operator|(PadFlags a, PadFlags b) { return static_cast<PadFlags>(static_cast<int>(a) | static_cast<int>(b)); }
-
 // default point definitions for PointND, PointNDlocal, PointNDglobal are in
 // MathUtils/CartesianND.h
 

DataFormats/Detectors/TPC/src/DataFormatsTPCLinkDef.h

@@ -22,15 +22,13 @@
 #pragma link C++ class o2::tpc::ClusterHardwareContainerFixedSize < 8192> + ;
 #pragma link C++ class o2::tpc::ClusterNativeContainer + ;
 #pragma link C++ class o2::tpc::Digit + ;
-#pragma link C++ enum o2::tpc::PadFlags + ; // enum itself
 #pragma link C++ class o2::tpc::ZeroSuppressedContainer8kb + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNative> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterNativeContainer> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardware> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainerFixedSize < 8192>> + ;
 #pragma link C++ class std::vector < o2::tpc::ClusterHardwareContainer8kb> + ;
 #pragma link C++ class std::vector < o2::tpc::Digit> + ;
-#pragma link C++ class std::vector < o2::tpc::PadFlags> + ;
 #pragma link C++ class std::vector < o2::tpc::ZeroSuppressedContainer8kb> + ;
 #pragma link C++ class o2::tpc::TrackTPC + ;
 #pragma link C++ class o2::tpc::LaserTrack + ;

Detectors/EMCAL/base/include/EMCALBase/ClusterFactory.h

@@ -401,6 +401,10 @@ class ClusterFactory
   /// in cell units
   void evalElipsAxis(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;
 
+  ///
+  /// Calculate the number of local maxima in the cluster
+  void evalNExMax(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;
+
   ///
   /// Time is set to the time of the digit with the maximum energy
   void evalTime(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const;

Detectors/EMCAL/base/include/EMCALBase/Geometry.h

@@ -429,6 +429,14 @@ class Geometry
   /// \return Position (0 - phi, 1 - eta) of the cell inside teh supermodule
   std::tuple<int, int> GetCellPhiEtaIndexInSModule(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
 
+  /// \brief Get topological row and column of cell in SM (same as for clusteriser with artifical gaps)
+  /// \param supermoduleID super module number
+  /// \param moduleID module number
+  /// \param phiInModule index in phi direction in module
+  /// \param etaInModule index in phi direction in module
+  /// \return tuple with (row, column) of the cell, which is global numbering scheme
+  std::tuple<short, short> GetTopologicalRowColumn(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const;
+
   /// \brief Adapt cell indices in supermodule to online indexing
   /// \param supermoduleID super module number of the channel/cell
   /// \param iphi row/phi cell index, modified for DCal

Detectors/EMCAL/base/src/ClusterFactory.cxx

@@ -120,6 +120,9 @@ o2::emcal::AnalysisCluster ClusterFactory<InputType>::buildCluster(int clusterIn
   evalElipsAxis(inputsIndices, clusterAnalysis);
   evalDispersion(inputsIndices, clusterAnalysis);
 
+  // evaluate number of local maxima
+  evalNExMax(inputsIndices, clusterAnalysis);
+
   evalCoreEnergy(inputsIndices, clusterAnalysis);
   evalTime(inputsIndices, clusterAnalysis);
 
@@ -489,6 +492,63 @@ void ClusterFactory<InputType>::evalCoreEnergy(gsl::span<const int> inputsIndice
   clusterAnalysis.setCoreEnergy(coreEnergy);
 }
 
+///
+/// Calculate the number of local maxima in the cluster
+//____________________________________________________________________________
+template <class InputType>
+void ClusterFactory<InputType>::evalNExMax(gsl::span<const int> inputsIndices, AnalysisCluster& clusterAnalysis) const
+{
+  // Pre-compute cell indices and energies for all cells in cluster to avoid multiple expensive geometry lookups
+  const size_t n = inputsIndices.size();
+  std::vector<short> rows;
+  std::vector<short> columns;
+  std::vector<double> energies;
+
+  rows.reserve(n);
+  columns.reserve(n);
+  energies.reserve(n);
+
+  for (auto iInput : inputsIndices) {
+    auto [nSupMod, nModule, nIphi, nIeta] = mGeomPtr->GetCellIndex(mInputsContainer[iInput].getTower());
+
+    // get a nice topological indexing that is done in exactly the same way as used by the clusterizer
+    // this way we can handle the shared cluster cases correctly
+    const auto [row, column] = mGeomPtr->GetTopologicalRowColumn(nSupMod, nModule, nIphi, nIeta);
+
+    rows.push_back(row);
+    columns.push_back(column);
+    energies.push_back(mInputsContainer[iInput].getEnergy());
+  }
+
+  // Now find local maxima using pre-computed data
+  int nExMax = 0;
+  for (size_t i = 0; i < n; i++) {
+    // this cell is assumed to be local maximum unless we find a higher energy cell in the neighborhood
+    bool isExMax = true;
+
+    // loop over all other cells in cluster
+    for (size_t j = 0; j < n; j++) {
+      if (i == j)
+        continue;
+
+      // adjacent cell is any cell with adjacent phi or eta index
+      if (std::abs(rows[i] - rows[j]) <= 1 &&
+          std::abs(columns[i] - columns[j]) <= 1) {
+
+        // if there is a cell with higher energy than the current cell, it is not a local maximum
+        if (energies[j] > energies[i]) {
+          isExMax = false;
+          break;
+        }
+      }
+    }
+    if (isExMax) {
+      nExMax++;
+    }
+  }
+  clusterAnalysis.setNExMax(nExMax);
+}
+
 ///
 /// Calculates the axis of the shower ellipsoid in eta and phi
 /// in cell units

Detectors/EMCAL/base/src/Geometry.cxx

@@ -1103,6 +1103,30 @@ std::tuple<int, int> Geometry::GetCellPhiEtaIndexInSModule(int supermoduleID, in
   return std::make_tuple(phiInSupermodule, etaInSupermodule);
 }
 
+std::tuple<short, short> Geometry::GetTopologicalRowColumn(int supermoduleID, int moduleID, int phiInModule, int etaInModule) const
+{
+  auto [iphi, ieta] = GetCellPhiEtaIndexInSModule(supermoduleID, moduleID, phiInModule, etaInModule);
+  int row = iphi;
+  int column = ieta;
+
+  // Add shifts wrt. supermodule and type of calorimeter
+  // NOTE:
+  // * Rows (phi) are arranged that one space is left empty between supermodules in phi
+  //   This is due to the physical gap that forbids clustering
+  // * For DCAL, there is an additional empty column between two supermodules in eta
+  //   Again, this is to account for the gap in DCAL
+
+  row += supermoduleID / 2 * (24 + 1);
+  // In DCAL, leave a gap between two SMs with same phi
+  if (!IsDCALSM(supermoduleID)) { // EMCAL
+    column += supermoduleID % 2 * 48;
+  } else {
+    column += supermoduleID % 2 * (48 + 1);
+  }
+
+  return std::make_tuple(static_cast<short>(row), static_cast<short>(column));
+}
+
 std::tuple<int, int> Geometry::ShiftOnlineToOfflineCellIndexes(Int_t supermoduleID, Int_t iphi, Int_t ieta) const
 {
   if (supermoduleID == 13 || supermoduleID == 15 || supermoduleID == 17) {

Detectors/EMCAL/calib/include/EMCALCalib/CellRecalibrator.h

@@ -62,7 +62,7 @@ class CellRecalibrator
  public:
   /// \class CellTypeException
   /// \brief Handling of invalid cell types in calibration
-  class CellTypeException : public std::exception
+  class CellTypeException final : public std::exception
   {
    public:
     /// \brief Constructor
@@ -73,7 +73,7 @@ class CellRecalibrator
 
     /// \brief Get error message of the exception
     /// \return Error message
-    const char* what() const noexcept final
+    [[nodiscard]] char const* what() const noexcept final
     {
       return "Only possible to calibrate cells of type high gain or low gain";
     }
@@ -208,4 +208,4 @@ std::ostream& operator<<(std::ostream& in, const CellRecalibrator& calib);
 
 } // namespace o2
 
-#endif // !ALCEO2_EMCAL_CELLRECALIBRATOR_H
+#endif // !ALCEO2_EMCAL_CELLRECALIBRATOR_H

Detectors/ITSMFT/common/reconstruction/include/ITSMFTReconstruction/Clusterer.h

@@ -121,6 +121,10 @@ class Clusterer
   };
 
   struct ClustererThread {
+    struct PreCluster {
+      int head = 0; // index of precluster head in the pixels
+      int index = 0;
+    };
     int id = -1;
     Clusterer* parent = nullptr; // parent clusterer
     // buffers for entries in preClusterIndices in 2 columns, to avoid boundary checks, we reserve
@@ -132,12 +136,11 @@ class Clusterer
     // pixels[].first is the index of the next pixel of the same precluster in the pixels
     // pixels[].second is the index of the referred pixel in the ChipPixelData (element of mChips)
     std::vector<std::pair<int, uint32_t>> pixels;
-    std::vector<int> preClusterHeads; // index of precluster head in the pixels
-    std::vector<int> preClusterIndices;
     uint16_t currCol = 0xffff;               ///< Column being processed
     bool noLeftCol = true;                   ///< flag that there is no column on the left to check
     std::array<Label, MaxLabels> labelsBuff; //! temporary buffer for building cluster labels
     std::vector<PixelData> pixArrBuff;       //! temporary buffer for pattern calc.
+    std::vector<PreCluster> preClusters;     //! preclusters info
     //
     /// temporary storage for the thread output
     CompClusCont compClusters;
@@ -154,7 +157,7 @@ class Clusterer
     ///< add cluster at row (entry ip in the ChipPixeData) to the precluster with given index
     void expandPreCluster(uint32_t ip, uint16_t row, int preClusIndex)
     {
-      auto& firstIndex = preClusterHeads[preClusterIndices[preClusIndex]];
+      auto& firstIndex = preClusters[preClusters[preClusIndex].index].head;
       pixels.emplace_back(firstIndex, ip);
       firstIndex = pixels.size() - 1;
       curr[row] = preClusIndex;
@@ -163,11 +166,10 @@ class Clusterer
     ///< add new precluster at given row of current column for the fired pixel with index ip in the ChipPixelData
     void addNewPrecluster(uint32_t ip, uint16_t row)
     {
-      preClusterHeads.push_back(pixels.size());
+      int lastIndex = preClusters.size();
+      preClusters.emplace_back(pixels.size(), lastIndex);
       // new head does not point yet (-1) on other pixels, store just the entry of the pixel in the ChipPixelData
       pixels.emplace_back(-1, ip);
-      int lastIndex = preClusterIndices.size();
-      preClusterIndices.push_back(lastIndex);
       curr[row] = lastIndex; // store index of the new precluster in the current column buffer
     }