Merge pull request #1165 from m-brettell/cluster_diameter_calculation

Bugfix and change to the cluster_diameter calculation

Author: m-brettell

core/include/traccc/clusterization/clustering_config.hpp

@@ -88,7 +88,7 @@ struct clustering_config {
      * See the enum definition for more details.
      */
     clustering_diameter_strategy diameter_strategy =
-        clustering_diameter_strategy::MAXIMUM;
+        clustering_diameter_strategy::CHANNEL1;
 
     /**
      * @brief The maximum number of cells per partition.

core/include/traccc/clusterization/details/measurement_creation.hpp

@@ -26,12 +26,14 @@ inline scalar signal_cell_modelling(
 ///
 /// @param cell      The cell to get the position of
 /// @param det_descr The (silicon) detector description
-/// @return The local position of the cell
+/// @return The local position of the cell (upper bound) and optionality the
+/// lower bound
 ///
 template <typename T>
 TRACCC_HOST_DEVICE inline vector2 position_from_cell(
     const edm::silicon_cell<T>& cell,
-    const silicon_detector_description::const_device& det_descr);
+    const silicon_detector_description::const_device& det_descr,
+    vector2* cell_lower_position = nullptr);
 
 /// Function used for calculating the properties of the cluster during
 /// measurement creation

core/include/traccc/clusterization/impl/measurement_creation.ipp

@@ -20,17 +20,25 @@ inline scalar signal_cell_modelling(
 template <typename T>
 TRACCC_HOST_DEVICE inline vector2 position_from_cell(
     const edm::silicon_cell<T>& cell,
-    const silicon_detector_description::const_device& det_descr) {
+    const silicon_detector_description::const_device& det_descr,
+    vector2* cell_lower_position) {
 
     // The detector description for the module that the cell is on.
     const auto module_dd = det_descr.at(cell.module_index());
     // Calculate / construct the local cell position.
-    return {module_dd.reference_x() +
-                (scalar{0.5f} + static_cast<scalar>(cell.channel0())) *
-                    module_dd.pitch_x(),
-            module_dd.reference_y() +
-                (scalar{0.5f} + static_cast<scalar>(cell.channel1())) *
-                    module_dd.pitch_y()};
+    vector2 upper_position = {
+        module_dd.reference_x() +
+            (scalar{0.5f} + static_cast<scalar>(cell.channel0())) *
+                module_dd.pitch_x(),
+        module_dd.reference_y() +
+            (scalar{0.5f} + static_cast<scalar>(cell.channel1())) *
+                module_dd.pitch_y()};
+
+    if (cell_lower_position) {
+        *cell_lower_position = {upper_position[0] - module_dd.pitch_x(),
+                                upper_position[1] - module_dd.pitch_y()};
+    }
+    return upper_position;
 }
 
 template <typename T>

device/common/include/traccc/clusterization/device/impl/aggregate_cluster.ipp

@@ -57,9 +57,9 @@ inline void aggregate_cluster(
     point2 mean{0.f, 0.f}, var{0.f, 0.f}, offset{0.f, 0.f};
 
     scalar min_channel0 = std::numeric_limits<scalar>::max();
-    scalar max_channel0 = std::numeric_limits<scalar>::min();
+    scalar max_channel0 = std::numeric_limits<scalar>::lowest();
     scalar min_channel1 = std::numeric_limits<scalar>::max();
-    scalar max_channel1 = std::numeric_limits<scalar>::min();
+    scalar max_channel1 = std::numeric_limits<scalar>::lowest();
 
     const unsigned int module_idx = cells.module_index().at(cid + start);
     const auto module_descr = det_descr.at(module_idx);
@@ -101,12 +101,14 @@ inline void aggregate_cluster(
                 totalWeight += weight;
                 scalar weight_factor = weight / totalWeight;
 
-                point2 cell_position =
-                    traccc::details::position_from_cell(cell, det_descr);
+                point2 cell_lower_position = {0, 0};
+                point2 cell_position = traccc::details::position_from_cell(
+                    cell, det_descr, &cell_lower_position);
 
-                min_channel0 = std::min(min_channel0, cell_position[0]);
+                // calculated from the most-extreme cell edges
+                min_channel0 = std::min(min_channel0, cell_lower_position[0]);
                 max_channel0 = std::max(max_channel0, cell_position[0]);
-                min_channel1 = std::min(min_channel1, cell_position[1]);
+                min_channel1 = std::min(min_channel1, cell_lower_position[1]);
                 max_channel1 = std::max(max_channel1, cell_position[1]);
 
                 if (!first_processed) {