Added implementation for hexagonal segmentation and also staggered square segmentations

DDCore/include/DDSegmentation/CartesianGridXY.h

@@ -65,6 +65,18 @@ namespace dd4hep {
       const std::string& fieldNameY() const {
         return _yId;
       }
+      /// access the staggering option in X
+      int staggerX() const {
+        return _staggerX;
+      }
+      /// access the staggering option in Y
+      int staggerY() const {
+        return _staggerY;
+      }
+      /// access the keyword used to determine which volumes to stagger
+      const std::string& staggerKeyword() const {
+        return _staggerKeyword;
+      }
       /// set the grid size in X
       void setGridSizeX(double cellSize) {
         _gridSizeX = cellSize;
@@ -89,6 +101,18 @@ namespace dd4hep {
       void setFieldNameY(const std::string& fieldName) {
         _yId = fieldName;
       }
+      /// set the staggering option in X
+      void setStaggerX(int staggerX) {
+        _staggerX = staggerX;
+      }
+      /// set the staggering option in Y
+      void setStaggerY(int staggerY) {
+        _staggerY = staggerY;
+      }
+      /// set the keyword used to determine which volumes to stagger
+      void setStaggerKeyword(const std::string& staggerKeyword) {
+        _staggerKeyword = staggerKeyword;
+      }
       /** \brief Returns a vector<double> of the cellDimensions of the given cell ID
           in natural order of dimensions, e.g., dx/dy/dz, or dr/r*dPhi
 
@@ -105,14 +129,20 @@ namespace dd4hep {
       double _gridSizeX;
       /// the coordinate offset in X
       double _offsetX;
+      /// staggering option in X.  0 = no staggering.  1 = stagger by _gridSizeX/2.0 in odd layers
+      int _staggerX;
       /// the grid size in Y
       double _gridSizeY;
       /// the coordinate offset in Y
       double _offsetY;
+      /// staggering option in Y.  0 = no staggering.  1 = stagger by _gridSizeY/2.0 in odd layers
+      int _staggerY;
       /// the field name used for X
       std::string _xId;
       /// the field name used for Y
       std::string _yId;
+      /// the keyword used to determine which volumes to stagger
+      std::string _staggerKeyword;
     };
 
   } /* namespace DDSegmentation */

DDCore/include/DDSegmentation/HexGrid.h

@@ -0,0 +1,131 @@
+//==========================================================================
+//  AIDA Detector description implementation 
+//--------------------------------------------------------------------------
+// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
+// All rights reserved.
+//
+// For the licensing terms see $DD4hepINSTALL/LICENSE.
+// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
+//
+//==========================================================================
+
+/*
+ * HexGrid.h
+ *
+ *  Created on: August 9, 2023
+ *      Author: Sebouh J. Paul, UC Riverside
+ */
+
+#ifndef DDSEGMENTATION_HEXGRID_H
+#define DDSEGMENTATION_HEXGRID_H
+
+#include "DDSegmentation/Segmentation.h"
+
+namespace dd4hep {
+  namespace DDSegmentation {
+
+    /// Segmentation base class describing hexagonal grid segmentation, with or without staggering
+    class HexGrid: public Segmentation {
+    public:
+      /// Destructor
+      virtual ~HexGrid();
+      //protected:
+      /// Default constructor used by derived classes passing the encoding string
+      HexGrid(const std::string& cellEncoding = "");
+      /// Default constructor used by derived classes passing an existing decoder
+      HexGrid(const BitFieldCoder* decoder);
+
+      /// determine the position based on the cell ID
+      virtual Vector3D position(const CellID& cellID) const;
+      /// determine the cell ID based on the position
+      virtual CellID cellID(const Vector3D& localPosition, const Vector3D& globalPosition, const VolumeID& volumeID) const;
+      // access the stagger mode: 0=no stagger; 1=stagger cycling through 3 offsets
+      int stagger() const {
+	return _stagger;
+      }
+
+      /// access the grid size 
+      double sideLength() const {
+        return _sideLength;
+      }
+      /// access the coordinate offset in X
+      double offsetX() const {
+        return _offsetX;
+      }
+      /// access the coordinate offset in Y
+      double offsetY() const {
+        return _offsetY;
+      }
+      /// access the field name used for X
+      const std::string& fieldNameX() const {
+        return _xId;
+      }
+      /// access the field name used for Y
+      const std::string& fieldNameY() const {
+        return _yId;
+      }
+      /// access the keyword for staggering
+      const std::string& staggerKeyword() const {
+        return _staggerKeyword;
+      }
+
+      /// set the stagger mode: 0=no stagger; 1=stagger cycling through 3 offsets
+      void setStagger(int stagger) {
+	_stagger= stagger;
+      }
+      /// set the grid size in X
+      void setSideLength(double cellSize) {
+        _sideLength = cellSize;
+      }
+      /// set the coordinate offset in X
+      void setOffsetX(double offset) {
+        _offsetX = offset;
+      }
+      /// set the coordinate offset in Y
+      void setOffsetY(double offset) {
+        _offsetY = offset;
+      }
+      /// set the field name used for X
+      void setFieldNameX(const std::string& fieldName) {
+        _xId = fieldName;
+      }
+      /// set the field name used for Y
+      void setFieldNameY(const std::string& fieldName) {
+        _yId = fieldName;
+      }
+      /// set the keyword used to determine which volumes to stagger
+      void setStaggerKeyword(const std::string& staggerKeyword) {
+        _staggerKeyword = staggerKeyword;
+      }
+      /** \brief Returns a vector<double> of the cellDimensions of the given cell ID
+          in natural order of dimensions, e.g., dx/dy/dz, or dr/r*dPhi
+
+          Returns a vector of the cellDimensions of the given cell ID
+          \param cellID is ignored as all cells have the same dimension
+          \return std::vector<double> size 2:
+          -# size in x
+          -# size in y
+      */
+      virtual std::vector<double> cellDimensions(const CellID& cellID) const;
+
+    protected:
+      /// the stagger mode:  0=off ; 1=cycle through 3 different offsets (H3)
+      //  2=cycle through 4 differnt offsets (H4)
+      int _stagger;
+      /// the length of one side of a hexagon
+      double _sideLength;
+      /// the coordinate offset in X
+      double _offsetX;
+      /// the coordinate offset in Y
+      double _offsetY;
+      /// the field name used for X
+      std::string _xId;
+      /// the field name used for Y
+      std::string _yId;
+      /// the keyword used to determine which volumes to stagger
+      std::string _staggerKeyword;
+    };
+
+  } /* namespace DDSegmentation */
+} /* namespace dd4hep */
+#endif // DDSEGMENTATION_HEXGRID_H

DDCore/src/segmentations/CartesianGridXY.cpp

@@ -22,8 +22,14 @@ CartesianGridXY::CartesianGridXY(const std::string& cellEncoding) :
 	registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
 	registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
 	registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
+	registerParameter("stagger_x", "Option to stagger the layers in x (ie, add grid_size_x/2 to offset_x for odd layers)", _staggerX, 0,
+		SegmentationParameter::NoUnit, true);
+	registerParameter("stagger_y", "Option to stagger the layers in y (ie, add grid_size_y/2 to offset_y for odd layers)", _staggerY, 0, 
+		SegmentationParameter::NoUnit, true);
 	registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
 	registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
+	registerParameter("stagger_keyword", "Volume ID identifier used for determining which volumes to stagger", _staggerKeyword, (std::string)"layer", 
+		SegmentationParameter::NoUnit, true);
 }
 
 /// Default constructor used by derived classes passing an existing decoder
@@ -39,8 +45,14 @@ CartesianGridXY::CartesianGridXY(const BitFieldCoder* decode) :
 	registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
 	registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
 	registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
+	registerParameter("stagger_x", "Option to stagger the layers in x (ie, add grid_size_x/2 to offset_x for odd layers)", _staggerX, 0,
+		SegmentationParameter::NoUnit, true);
+	registerParameter("stagger_y", "Option to stagger the layers in y (ie, add grid_size_y/2 to offset_y for odd layers)", _staggerY, 0,
+		SegmentationParameter::NoUnit, true);
 	registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
 	registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
+	registerParameter("stagger_keyword", "Volume ID identifier used for determining which volumes to stagger", _staggerKeyword, (std::string)"layer",
+		SegmentationParameter::NoUnit, true);
 }
 
 /// destructor
@@ -51,16 +63,28 @@ CartesianGridXY::~CartesianGridXY() {
 /// determine the position based on the cell ID
 Vector3D CartesianGridXY::position(const CellID& cID) const {
 	Vector3D cellPosition;
-	cellPosition.X = binToPosition( _decoder->get(cID,_xId ), _gridSizeX, _offsetX);
-	cellPosition.Y = binToPosition( _decoder->get(cID,_yId ), _gridSizeY, _offsetY);
+	if (_staggerX || _staggerY){
+		int layer= _decoder->get(cID,_staggerKeyword);
+		cellPosition.X = binToPosition( _decoder->get(cID,_xId ), _gridSizeX, _offsetX+_staggerX*_gridSizeX*(layer%2)/2.);
+		cellPosition.Y = binToPosition( _decoder->get(cID,_yId ), _gridSizeY, _offsetY+_staggerY*_gridSizeY*(layer%2)/2.);
+	} else {
+		cellPosition.X = binToPosition( _decoder->get(cID,_xId ), _gridSizeX, _offsetX);
+		cellPosition.Y = binToPosition( _decoder->get(cID,_yId ), _gridSizeY, _offsetY);
+	}
 	return cellPosition;
 }
 
 /// determine the cell ID based on the position
   CellID CartesianGridXY::cellID(const Vector3D& localPosition, const Vector3D& /* globalPosition */, const VolumeID& vID) const {
         CellID cID = vID ;
-	_decoder->set( cID,_xId, positionToBin(localPosition.X, _gridSizeX, _offsetX) );
-	_decoder->set( cID,_yId, positionToBin(localPosition.Y, _gridSizeY, _offsetY) );
+	if (_staggerX || _staggerY){
+		int layer= _decoder->get(cID,_staggerKeyword);
+		_decoder->set( cID,_xId, positionToBin(localPosition.X, _gridSizeX, _offsetX+_staggerX*_gridSizeX*(layer%2)/2) );
+		_decoder->set( cID,_yId, positionToBin(localPosition.Y, _gridSizeY, _offsetY+_staggerY*_gridSizeY*(layer%2)/2) );
+	} else {
+		_decoder->set( cID,_xId, positionToBin(localPosition.X, _gridSizeX, _offsetX));
+		_decoder->set( cID,_yId, positionToBin(localPosition.Y, _gridSizeY, _offsetY));
+	}
 	return cID ;
 }