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 <algorithm>
0023 #include <sstream>
0024 #include <stdexcept>
0025 #include <cmath>
0026
0027 namespace dd4hep {
0028 namespace DDSegmentation {
0029
0030 /// default constructor using an encoding string
0031 TiledLayerGridXY::TiledLayerGridXY(const std::string& cellEncoding) :
0032         CartesianGrid(cellEncoding) {
0033     // define type and description
0034     _type = "TiledLayerGridXY";
0035     _description = "Cartesian segmentation in the local XY-plane using optimal tiling depending on the layer dimensions";
0036
0037     printout(INFO, "TiledLayerGridXY", " ######### dd4hep::DDSegmentation::TiledLayerGridXY() ");
0038
0039     // register all necessary parameters
0040     registerParameter("grid_size_x", "Cell size in X", _gridSizeX, 1., SegmentationParameter::LengthUnit);
0041     registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
0042     registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
0043     registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
0044     registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
0045     registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
0046     registerIdentifier("identifier_layer", "Cell encoding identifier for layer", _identifierLayer, "layer");
0047     registerParameter("layer_offsetX", "List of layer x offset", _layerOffsetX, std::vector<double>(),
0048             SegmentationParameter::NoUnit, true);
0049     registerParameter("layer_offsetY", "List of layer y offset", _layerOffsetY, std::vector<double>(),
0050             SegmentationParameter::NoUnit, true);
0051 }
0052
0053 /// Default constructor used by derived classes passing an existing decoder
0054 TiledLayerGridXY::TiledLayerGridXY(const BitFieldCoder* decode) : CartesianGrid(decode) {
0055     // define type and description
0056     _type = "TiledLayerGridXY";
0057     _description = "Cartesian segmentation in the local XY-plane using optimal tiling depending on the layer dimensions";
0058
0059     printout(INFO, "TiledLayerGridXY", " ######### dd4hep::DDSegmentation::TiledLayerGridXY() ");
0060
0061     // register all necessary parameters
0062     registerParameter("grid_size_x", "Cell size in X", _gridSizeX, 1., SegmentationParameter::LengthUnit);
0063     registerParameter("grid_size_y", "Cell size in Y", _gridSizeY, 1., SegmentationParameter::LengthUnit);
0064     registerParameter("offset_x", "Cell offset in X", _offsetX, 0., SegmentationParameter::LengthUnit, true);
0065     registerParameter("offset_y", "Cell offset in Y", _offsetY, 0., SegmentationParameter::LengthUnit, true);
0066     registerIdentifier("identifier_x", "Cell ID identifier for X", _xId, "x");
0067     registerIdentifier("identifier_y", "Cell ID identifier for Y", _yId, "y");
0068     registerIdentifier("identifier_layer", "Cell encoding identifier for layer", _identifierLayer, "layer");
0069     registerParameter("layer_offsetX", "List of layer x offset", _layerOffsetX, std::vector<double>(),
0070             SegmentationParameter::NoUnit, true);
0071     registerParameter("layer_offsetY", "List of layer y offset", _layerOffsetY, std::vector<double>(),
0072             SegmentationParameter::NoUnit, true);
0073 }
0074
0075 /// destructor
0076 TiledLayerGridXY::~TiledLayerGridXY() {
0077
0078 }
0079
0080 /// determine the position based on the cell ID
0081 Vector3D TiledLayerGridXY::position(const CellID& cID) const {
0082     unsigned int _layerIndex;
0083     Vector3D cellPosition;
0084
0085     // AHcal: _layerIndex is [1,48], _layerOffsetX is [0,47]
0086     _layerIndex = _decoder->get(cID,_identifierLayer);
0087
0088     if ( _layerOffsetX.size() != 0 && _layerIndex <=_layerOffsetX.size() ) {
0089       cellPosition.X = binToPosition(_decoder->get(cID,_xId), _gridSizeX, _layerOffsetX[_layerIndex - 1]*_gridSizeX/2.);
0090       // check the integer cell boundary in x,
0091       if ( ( _layerDimX.size() != 0 && _layerIndex <= _layerDimX.size() )
0092            &&( _fractCellSizeXPerLayer.size() != 0 && _layerIndex <=  _fractCellSizeXPerLayer.size() )
0093            &&(std::fabs( cellPosition.X ) > ( _layerDimX.at(_layerIndex - 1) - _fractCellSizeXPerLayer.at(_layerIndex - 1) ))
0094            )
0095         {
0096           // and correct the fraction cell center position in x.
0097           cellPosition.X = cellPosition.X/std::fabs(cellPosition.X)
0098         *(_layerDimX.at(_layerIndex - 1) - _fractCellSizeXPerLayer.at(_layerIndex - 1)/2.0) ;
0099         }
0100     } else {
0101       cellPosition.X = binToPosition(_decoder->get(cID,_xId), _gridSizeX, _offsetX);
0102     }
0103     cellPosition.Y = binToPosition(_decoder->get(cID,_yId), _gridSizeY, _offsetY);
0104     return cellPosition;
0105 }
0106
0107 /// determine the cell ID based on the position
0108   CellID TiledLayerGridXY::cellID(const Vector3D& localPosition, const Vector3D& /* globalPosition */, const VolumeID& vID) const {
0109     CellID cID = vID ;
0110     unsigned int _layerIndex;
0111
0112     // AHcal: _layerIndex is [1,48], _layerOffsetX is [0,47]
0113     _layerIndex = _decoder->get(cID,_identifierLayer);
0114
0115     if ( _layerOffsetX.size() != 0 && _layerIndex <=_layerOffsetX.size() ) {
0116       _decoder->set(cID,_xId,positionToBin(localPosition.X, _gridSizeX, _layerOffsetX[_layerIndex - 1]*_gridSizeX/2.));
0117     } else {
0118       _decoder->set(cID,_xId,positionToBin(localPosition.X, _gridSizeX, _offsetX));
0119     }
0120     _decoder->set(cID,_yId, positionToBin(localPosition.Y, _gridSizeY, _offsetY));
0121     return cID;
0122 }
0123
0124 std::vector<double> TiledLayerGridXY::cellDimensions(const CellID&) const {
0125 #if __cplusplus >= 201103L
0126   return {_gridSizeX, _gridSizeY};
0127 #else
0128   std::vector<double> cellDims(2,0.0);
0129   cellDims[0] = _gridSizeX;
0130   cellDims[1] = _gridSizeY;
0131   return cellDims;
0132 #endif
0133 }
0134
0135
0136 } /* namespace DDSegmentation */
0137 } /* namespace dd4hep */