src/segmentations/TiledLayerGridXY.cpp

0001 //==========================================================================
0002 //  AIDA Detector description implementation
0003 //--------------------------------------------------------------------------
0004 // Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
0005 // All rights reserved.
0006 //
0007 // For the licensing terms see $DD4hepINSTALL/LICENSE.
0008 // For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
0009 //
0010 //==========================================================================
0011 /*
0012  * TiledLayerGridXY.cpp
0013  *
0014  *  Created on: November 12, 2015
0015  *      Author: Shaojun Lu, DESY
0016  */
0017
0018 #include <DDSegmentation/TiledLayerGridXY.h>
0019 #include <DD4hep/Printout.h>
0020
0021 // C/C++ includes
0022 #include <cmath>
0023 #include <string>
0024
0025 namespace dd4hep {
0026 namespace DDSegmentation {
0027
0028 /// default constructor using an encoding string
0029 TiledLayerGridXY::TiledLayerGridXY(const std::string& cellEncoding) :
0030         CartesianGrid(cellEncoding) {
0031     // define type and description
0032     _type = "TiledLayerGridXY";
0033     _description = "Cartesian segmentation in the local XY-plane using optimal tiling depending on the layer dimensions";
0034
0035     printout(INFO, "TiledLayerGridXY", " ######### dd4hep::DDSegmentation::TiledLayerGridXY() ");
0036
0037     // register all necessary parameters
0038     registerParameter("grid_size_x", "Cell size in X", _gridSizeX, 1., SegmentationParameter::LengthUnit);
0039     registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
0040     registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
0041     registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
0042     registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
0043     registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
0044     registerIdentifier("identifier_layer", "Cell encoding identifier for layer", _identifierLayer, "layer");
0045     registerParameter("layer_offsetX", "List of layer x offset", _layerOffsetX, std::vector<double>(),
0046             SegmentationParameter::NoUnit, true);
0047     registerParameter("layer_offsetY", "List of layer y offset", _layerOffsetY, std::vector<double>(),
0048             SegmentationParameter::NoUnit, true);
0049 }
0050
0051 /// Default constructor used by derived classes passing an existing decoder
0052 TiledLayerGridXY::TiledLayerGridXY(const BitFieldCoder* decode) : CartesianGrid(decode) {
0053     // define type and description
0054     _type = "TiledLayerGridXY";
0055     _description = "Cartesian segmentation in the local XY-plane using optimal tiling depending on the layer dimensions";
0056
0057     printout(INFO, "TiledLayerGridXY", " ######### dd4hep::DDSegmentation::TiledLayerGridXY() ");
0058
0059     // register all necessary parameters
0060     registerParameter("grid_size_x", "Cell size in X", _gridSizeX, 1., SegmentationParameter::LengthUnit);
0061     registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
0062     registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
0063     registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
0064     registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
0065     registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
0066     registerIdentifier("identifier_layer", "Cell encoding identifier for layer", _identifierLayer, "layer");
0067     registerParameter("layer_offsetX", "List of layer x offset", _layerOffsetX, std::vector<double>(),
0068             SegmentationParameter::NoUnit, true);
0069     registerParameter("layer_offsetY", "List of layer y offset", _layerOffsetY, std::vector<double>(),
0070             SegmentationParameter::NoUnit, true);
0071 }
0072
0073 /// destructor
0074 TiledLayerGridXY::~TiledLayerGridXY() {
0075
0076 }
0077
0078 /// determine the position based on the cell ID
0079 Vector3D TiledLayerGridXY::position(const CellID& cID) const {
0080     unsigned int _layerIndex;
0081     Vector3D cellPosition;
0082
0083     // AHcal: _layerIndex is [1,48], _layerOffsetX is [0,47]
0084     _layerIndex = _decoder->get(cID,_identifierLayer);
0085
0086     if ( _layerOffsetX.size() != 0 && _layerIndex <=_layerOffsetX.size() ) {
0087       cellPosition.X = binToPosition(_decoder->get(cID,_xId), _gridSizeX, _layerOffsetX[_layerIndex - 1]*_gridSizeX/2.);
0088       // check the integer cell boundary in x,
0089       if ( ( _layerDimX.size() != 0 && _layerIndex <= _layerDimX.size() )
0090            &&( _fractCellSizeXPerLayer.size() != 0 && _layerIndex <=  _fractCellSizeXPerLayer.size() )
0091            &&(std::fabs( cellPosition.X ) > ( _layerDimX.at(_layerIndex - 1) - _fractCellSizeXPerLayer.at(_layerIndex - 1) ))
0092            )
0093         {
0094           // and correct the fraction cell center position in x.
0095           cellPosition.X = cellPosition.X/std::fabs(cellPosition.X)
0096         *(_layerDimX.at(_layerIndex - 1) - _fractCellSizeXPerLayer.at(_layerIndex - 1)/2.0) ;
0097         }
0098     } else {
0099       cellPosition.X = binToPosition(_decoder->get(cID,_xId), _gridSizeX, _offsetX);
0100     }
0101     cellPosition.Y = binToPosition(_decoder->get(cID,_yId), _gridSizeY, _offsetY);
0102     return cellPosition;
0103 }
0104
0105 /// determine the cell ID based on the position
0106   CellID TiledLayerGridXY::cellID(const Vector3D& localPosition, const Vector3D& /* globalPosition */, const VolumeID& vID) const {
0107     CellID cID = vID ;
0108     unsigned int _layerIndex;
0109
0110     // AHcal: _layerIndex is [1,48], _layerOffsetX is [0,47]
0111     _layerIndex = _decoder->get(cID,_identifierLayer);
0112
0113     if ( _layerOffsetX.size() != 0 && _layerIndex <=_layerOffsetX.size() ) {
0114       _decoder->set(cID,_xId,positionToBin(localPosition.X, _gridSizeX, _layerOffsetX[_layerIndex - 1]*_gridSizeX/2.));
0115     } else {
0116       _decoder->set(cID,_xId,positionToBin(localPosition.X, _gridSizeX, _offsetX));
0117     }
0118     _decoder->set(cID,_yId, positionToBin(localPosition.Y, _gridSizeY, _offsetY));
0119     return cID;
0120 }
0121
0122 std::vector<double> TiledLayerGridXY::cellDimensions(const CellID&) const {
0123   return {_gridSizeX, _gridSizeY};
0124 }
0125
0126
0127 } /* namespace DDSegmentation */
0128 } /* namespace dd4hep */