TiledLayerSegmentation.h

Go to the documentation of this file.

//==========================================================================
//  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.
//
//==========================================================================
 
/*
 * TiledLayerSegmentation.h
 *
 *  Created on: Mar 10, 2014
 *      Author: cgrefe
 */
 
#ifndef DDSEGMENTATION_TILEDLAYERSEGMENTATION_H
#define DDSEGMENTATION_TILEDLAYERSEGMENTATION_H
 
#include <DDSegmentation/Segmentation.h>
 
// C/C++ includes
#include <string>
#include <vector>
 
namespace dd4hep {
  namespace DDSegmentation {
 
    class TiledLayerSegmentation: public Segmentation {
    public:
      struct LayerDimensions {
        LayerDimensions(double _x = 1., double _y = 1.) :
          x(_x), y(_y) {}
        double x, y;
      };
 
      TiledLayerSegmentation(const std::string& cellEncoding = "");
      TiledLayerSegmentation(const BitFieldCoder* decoder);
      virtual ~TiledLayerSegmentation();
 
      virtual Vector3D position(const CellID& cellID) const;
      virtual CellID cellID(const Vector3D& localPosition, const Vector3D& globalPosition,
                            const VolumeID& volumeID) const;
 
      double gridSizeX() const {
        return _gridSizeX;
      }
      double gridSizeY() const {
        return _gridSizeY;
      }
 
      double layerGridSizeX(int layerIndex) const;
      double layerGridSizeY(int layerIndex) const;
 
      const std::string& identifierX() const {
        return _identifierX;
      }
      const std::string& identifierY() const {
        return _identifierY;
      }
      const std::string& identifierLayer() const {
        return _identifierLayer;
      }
 
      LayerDimensions layerDimensions(int layerIndex) const;
 
      void setGridSizeX(double cellSize) {
        _gridSizeX = cellSize;
      }
      void setGridSizeY(double cellSize) {
        _gridSizeY = cellSize;
      }
 
      void setIdentifierX(const std::string& fieldName) {
        _identifierX = fieldName;
      }
      void setIdentifierY(const std::string& fieldName) {
        _identifierY = fieldName;
      }
      void setIdentifierLayer(const std::string& fieldName) {
        _identifierLayer = fieldName;
      }
 
      void setLayerDimensions(int layerIndex, double x, double y);
 
 
 
    protected:
      double _gridSizeX; 
      double _gridSizeY; 
      std::string _identifierX; 
      std::string _identifierY; 
      std::string _identifierLayer; 
      std::vector<int> _layerIndices; 
      std::vector<double> _layerDimensionsX; 
      std::vector<double> _layerDimensionsY; 
 
      static double calculateOptimalCellSize(double nominalCellSize, double totalSize);
      static double calculateOffset(double cellSize, double totalSize);
    };
 
  } /* namespace DDSegmentation */
} /* namespace dd4hep */
 
#endif // DDSEGMENTATION_TILEDLAYERSEGMENTATION_H