Added implementation for hexagonal segmentation and also staggered square segmentations

DDCore/include/DDSegmentation/HexGrid.h

@@ -0,0 +1,121 @@
+//==========================================================================
+//  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;
+      }
+
+      /// 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;
+      }
+      /** \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;
+    };
+
+  } /* namespace DDSegmentation */
+} /* namespace dd4hep */
+#endif // DDSEGMENTATION_HEXGRID_H

DDCore/include/DDSegmentation/SquareGrid.h

@@ -0,0 +1,121 @@
+//==========================================================================
+//  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.
+//
+//==========================================================================
+
+/*
+ * SquareGrid.h
+ *
+ *  Created on: August 9, 2023
+ *      Author: Sebouh J. Paul, UC Riverside
+ */
+
+#ifndef DDSEGMENTATION_SQUAREGRID_H
+#define DDSEGMENTATION_SQUAREGRID_H
+
+#include "DDSegmentation/Segmentation.h"
+
+namespace dd4hep {
+  namespace DDSegmentation {
+
+    /// Segmentation base class describing a cartesian grid segmentation with square
+    /// cells, with or without staggering
+    class SquareGrid: public Segmentation {
+    public:
+      /// Destructor
+      virtual ~SquareGrid();
+      //protected:
+      /// Default constructor used by derived classes passing the encoding string
+      SquareGrid(const std::string& cellEncoding = "");
+      /// Default constructor used by derived classes passing an existing decoder
+      SquareGrid(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;
+      }
+
+      /// 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;
+      }
+      /** \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 2 differnt offsets
+      int _stagger;
+      /// the length of one side of a square
+      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;
+    };
+
+  } /* namespace DDSegmentation */
+} /* namespace dd4hep */
+#endif // DDSEGMENTATION_SQUAREGRID_H

DDCore/src/segmentations/HexGrid.cpp

@@ -0,0 +1,150 @@
+/*
+ * HexGrid.cpp
+ *
+ *  Created on: August 9, 2023
+ *      Author: Sebouh J. Paul, UC Riverside
+ */
+#include "DD4hep/Factories.h"
+#include "HexGrid.h"
+
+namespace dd4hep {
+  namespace DDSegmentation {
+
+    /// Default constructor used by derived classes passing the encoding string
+    HexGrid::HexGrid(const std::string& cellEncoding) :
+      Segmentation(cellEncoding) {
+      _type = "HexGridXY";
+	_description = "Hexagonal segmentation in the local XY-plane";
+
+	// register all necessary parameters
+	registerParameter("stagger", "stagger mode", _stagger, 1);
+	registerParameter("side_length", "Cell size", _sideLength, 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);
+	registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
+	registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
+    }
+
+    /// Default constructor used by derived classes passing an existing decoder
+    HexGrid::HexGrid(const BitFieldCoder* decode) : Segmentation(decode) {
+      // define type and description
+	_type = "HexGridXY";
+	_description = "Hexagonal segmentation in the local XY-plane";
+
+	// register all necessary parameters                                                                        
+        registerParameter("stagger", "stagger mode", _stagger, 1);
+	registerParameter("side_length", "Cell size", _sideLength, 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);
+	registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
+	registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
+
+    }
+
+    /// Destructor
+    HexGrid::~HexGrid() {
+    }
+
+    /// determine the position based on the cell ID
+    Vector3D HexGrid::position(const CellID& cID) const {
+        int layer= _decoder->get(cID,"layer");
+	Vector3D cellPosition;
+	cellPosition.X = _decoder->get(cID,_xId )*1.5*_sideLength+_offsetX+_sideLength/2.;
+	cellPosition.Y = _decoder->get(cID,_yId )*std::sqrt(3)/2.*_sideLength+ _offsetY+_sideLength*std::sqrt(3)/2.;
+	if (_stagger==0)
+	  cellPosition.X+=_sideLength;
+	else if (_stagger==1)
+	  cellPosition.X+=(layer%3)*_sideLength;
+	else if (_stagger==2){
+	  switch (layer%4){
+	  case 0:
+	    cellPosition.X-=0.75*_sideLength;
+	    break;
+	  case 1:
+	    //cellPosition.X+=0.75*_sideLength;
+	    cellPosition.Y+=std::sqrt(3)/4*_sideLength;
+	    break;
+	  case 2:
+	    //cellPosition.X-=0.75*_sideLength;
+	    cellPosition.Y-=std::sqrt(3)/4*_sideLength;
+	    break;
+	  case 3:
+	    cellPosition.X+=0.75*_sideLength;
+	    break;
+	  }
+	}
+	return cellPosition;
+    }
+
+    inline double positive_modulo(double i, double n) {
+      return std::fmod(std::fmod(i,n) + n,n);
+    }
+
+    //inline double positive_floor(
+
+    /// determine the cell ID based on the position
+    CellID HexGrid::cellID(const Vector3D& localPosition, const Vector3D& /* globalPosition */, const VolumeID& vID) const {
+        CellID cID = vID ;
+	int layer= _decoder->get(cID,"layer");
+	double _gridSizeY=std::sqrt(3)*_sideLength/2.;
+	double _gridSizeX=3*_sideLength/2;
+
+	double x=localPosition.X-_offsetX;
+	double y=localPosition.Y-_offsetY;
+	if (_stagger==0)
+	  x-=_sideLength;
+	else if (_stagger==1)
+          x-=(layer%3)*_sideLength;
+	else if (_stagger==2){
+          switch (layer%4){
+	  case 0:
+	    x+=0.75*_sideLength;
+	    break;
+          case 1:
+            //x-=0.75*_sideLength;
+            y-=std::sqrt(3)/4*_sideLength;
+            break;
+          case 2:
+            //x+=0.75*_sideLength;
+            y+=std::sqrt(3)/4*_sideLength;
+            break;
+          case 3:
+            x-=0.75*_sideLength;
+	    break;
+          }
+        }
+
+	double a=positive_modulo(y/(std::sqrt(3)*_sideLength),1);
+	double b=positive_modulo(x/(3*_sideLength),1);
+	int ix = std::floor(x/(3*_sideLength/2.))+		
+	  (b<0.5)*(-abs(a-.5)<(b-.5)*3)+(b>0.5)*(abs(a-.5)-.5<(b-1)*3);
+	int iy=std::floor(y/(std::sqrt(3)*_sideLength/2.));
+	iy-=(ix+iy)&1;
+
+
+	//int ix=int(floor((localPosition.X - _offsetX) / (3/2*_sideLength)));
+	//int iy=int(floor((localPosition.Y - _offsetY) / (std::sqrt(3)/2*_sideLength)));
+		   //if((ix+iy)%2 &&
+		   //   ((localPosition.X-offset_X)/(2*_sideLength)+(localPosition.Y-_offsetX)/(std::sqrt(3)*_sideLength))
+		   //iy-=1;
+
+	_decoder->set( cID,_xId, ix );
+	_decoder->set( cID,_yId, iy );
+	return cID ;
+    }
+
+    std::vector<double> HexGrid::cellDimensions(const CellID&) const {
+#if __cplusplus >= 201103L
+      return {2*_sideLength, std::sqrt(3)*_sideLength};
+#else
+      std::vector<double> cellDims(2,0.0);
+      cellDims[0] = 2*_sideLength;
+      cellDims[1] = std::sqrt(3)*_sideLength;
+      return cellDims;
+#endif
+}
+
+  } /* namespace DDSegmentation */
+} /* namespace dd4hep */
+
+DECLARE_SEGMENTATION(HexGrid, create_segmentation<dd4hep::DDSegmentation::HexGrid>)